Eu estou no processo de refatorar uma quantidade muito grande de código, principalmente C ++, para remover um número de verificações de configuração temporárias que se tornaram permanentemente definidas para determinados valores. Por exemplo, eu teria o seguinte 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>

onde as chamadas para valor retornam um bool ou um int. Como eu sei os valores que essas chamadas sempre retornam, eu fiz algumas substituições regex para expandir as chamadas para seus valores normais:

<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>

Observe que, embora os valores sejam fixos, eles não são definidos em tempo de compilação, mas são lidos na memória compartilhada, de modo que o compilador não está atualmente otimizando nada nos bastidores.

Embora o código resultante pareça um pouco bobo, essa abordagem regex alcança muito do que eu quero, já que é simples de aplicar e remove a dependência das chamadas, embora não altere o comportamento do código e também é provável que o compilador possa otimizar um muito disso sabendo que um bloco nunca pode ser chamado ou um cheque sempre retornará verdadeiro. Ele também torna razoavelmente fácil (especialmente quando se difere do controle de versão) para ver o que mudou e dar o passo final de limpá-lo para que o código acima do código tenha a seguinte aparência:

<code>// do something

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

// more stuff again
</code>

O problema é que eu tenho centenas (possivelmente milhares) de mudanças para obter do segundo estágio, correto mas bobo, para chegar ao código final limpo.

Gostaria de saber se alguém sabia de uma ferramenta de refatoração que pudesse lidar com isso ou com qualquer técnica que eu pudesse aplicar. O principal problema é que a sintaxe do C ++ torna a expansão ou a eliminação total muito difícil de ser alcançada e há muitas permutações no código acima. Eu sinto que quase preciso de um compilador para lidar com a variação da sintaxe que eu precisaria cobrir.

Eu sei que tem havido perguntas semelhantes, mas não consigo encontrar nenhum requisito como este e também se perguntou se alguma ferramenta ou procedimentos surgiram desde que foram perguntados?