Estoy en el proceso de refactorizar una gran cantidad de código, principalmente C ++, para eliminar una serie de comprobaciones de configuración temporales que se han establecido permanentemente en valores dados. Así por ejemplo, tendría el siguiente código:

<code>#include <value1.h>
#include <value2.h>
#include <value3.h>

...

if ( value1() )
{
    // do something
}

bool b = value2();

if ( b && anotherCondition )
{
    // do more stuff
}

if ( value3() < 10 )
{
    // more stuff again
}
</code>

donde las llamadas a valor devuelven un bool o un int. Como conozco los valores que siempre devuelven estas llamadas, he realizado algunas sustituciones de expresiones regulares para expandir las llamadas a sus valores normales:

<code>// where:
//   value1() == true
//   value2() == false
//   value3() == 4

// TODO: Remove expanded config (value1)
if ( true )
{
    // do something
}

// TODO: Remove expanded config (value2)
bool b = false;

if ( b && anotherCondition )
{
    // do more stuff
}

// TODO: Remove expanded config (value3)
if ( 4 < 10 )
{
    // more stuff again
}
</code>

Tenga en cuenta que aunque los valores son fijos, no se configuran en el momento de la compilación sino que se leen desde la memoria compartida, por lo que el compilador no está optimizando nada detrás de las escenas.

Aunque el código resultante parece un poco tonto, este enfoque de expresiones regulares logra mucho de lo que quiero, ya que es fácil de aplicar y elimina la dependencia de las llamadas, sin cambiar el comportamiento del código y también es probable que el compilador pueda optimizar una Mucho de esto sabiendo que nunca se puede llamar a un bloque o que un cheque siempre devolverá verdadero. También hace que sea razonablemente fácil (especialmente cuando se compara con el control de versión) ver qué ha cambiado y tomar el último paso para limpiarlo, de modo que el código anterior se vea como sigue:

<code>// do something

// DONT do more stuff (b being false always prevented this)

// more stuff again
</code>

El problema es que tengo cientos (posiblemente miles) de cambios que hacer para obtener la segunda etapa, correcta pero tonta, para llegar al código final limpio.

Me pregunté si alguien sabía de una herramienta de refactorización que pudiera manejar esta o alguna de las técnicas que podría aplicar. El principal problema es que la sintaxis de C ++ hace que la expansión o eliminación completa sea bastante difícil de lograr y hay muchas permutaciones al código anterior. Creo que casi necesito un compilador para lidiar con la variación de sintaxis que necesitaría cubrir.

Sé que ha habido preguntas similares, pero no puedo encontrar ningún requisito como este y también me pregunto si surgieron herramientas o procedimientos desde que se les preguntó.