Otimização (-o) e CTFE (@puro)
Passar -o ativa otimizações do compilador e -O2 no Clang/GCC. Regra de ouro do CGD: otimizar nunca pode mudar o comportamento observável, apagar efeitos ou esconder exceções.
Calculando resultados na compilação com @puro
Coloque o decorador @puro acima de uma função livre ou de um método estático que só depende dos próprios parâmetros. Com -o, quando ela for chamada com valores constantes, a VM interna do CGD calcula o resultado durante a compilação e substitui direto no código C gerado. A sintaxe antiga //>puro segue aceita por compatibilidade, mas @puro é a forma recomendada.
@puro
funcao fatorial(n: inteiro): inteiro {
se n <= 1 { retorna 1 }
retorna n * fatorial(n - 1)
}
const resultado: inteiro = fatorial(6) // já vira 720 com -o
O que o otimizador simplifica com segurança
O gerenciador de passes roda até atingir ponto fixo: dobra operações constantes (aritmética, unários, comparações, textos), propaga constantes tipadas com segurança, simplifica curto-circuito (verdadeiro e x, falso ou x) e remove caudas comprovadamente inalcançáveis — preservando blocos finalmente e efeitos colaterais.
Experimente: 26_ctfe
// A VM é usada na compilação, não na execução do binário final.
//>puro
funcao fibonacci(n: inteiro): inteiro {
se n < 2 {
retorna n
}
retorna fibonacci(n - 1) + fibonacci(n - 2)
}
escreva(fibonacci(10))
Ver exemplo completo e contrato de teste no GitHub
Experimente: 01_constantes_escopos
// A propagação usa a declaração resolvida, preservando o sombreamento.
const valor: numero = 2
se verdadeiro {
const valor: numero = 9
escreva(valor + 1)
}
escreva(valor + 1)
Ver exemplo completo e contrato de teste no GitHub
Experimente: 02_efeitos
// Mesmo com -o, multiplicar por zero não elimina a avaliação da função.
funcao calcular(): qualquer {
escreva("efeito")
retorna 7
}
escreva(calcular() * 0)
Ver exemplo completo e contrato de teste no GitHub
Experimente: 03_fluxo
// --verificar avisa sobre a cauda inalcançável; finalmente permanece em -o.
funcao resultado(): qualquer {
tente {
retorna (2 + 3) * 4
escreva("inalcançável")
} finalmente {
escreva("limpeza")
}
}
escreva(resultado())
Ver exemplo completo e contrato de teste no GitHub
Experimente: 04_curto_circuito
funcao proibida(): qualquer {
falhar "Não deveria executar"
}
escreva(verdadeiro ? 7 : proibida(), falso e proibida(), verdadeiro ou proibida(), nulo ?: 8)
Ver exemplo completo e contrato de teste no GitHub
Experimente: 07_metodos_e_padroes
// Os passes também visitam métodos, valores padrão e funções anônimas.
classe Medida {
dobro(valor: qualquer = 1 + 1): qualquer {
retorna valor * 2
}
}
var calcular: funcao = funcao(valor: qualquer = 3 + 4): qualquer {
retorna valor
}
escreva(Medida().dobro(), calcular())
Ver exemplo completo e contrato de teste no GitHub
Experimente: 09_ctfe_fluxo_escopos
// A VM preserva senão, slots locais, parâmetros mutáveis e ordem de argumentos.
//>puro
funcao escolher(condicao: qualquer): qualquer {
se condicao {
retorna 1
} senao {
retorna 2
}
}
//>puro
funcao combinar(a: qualquer, b: qualquer): qualquer {
retorna a * 10 + b
}
//>puro
funcao calcular(): qualquer {
var valor: numero = 1
se verdadeiro {
var valor: numero = 99
}
retorna combinar(valor++, valor++)
}
escreva(escolher(falso), calcular())
Ver exemplo completo e contrato de teste no GitHub
Experimente: 10_ctfe_excecao
// Uma falha da CTFE preserva a chamada para permitir tratamento em execução.
//>puro
funcao dividir(valor: qualquer): qualquer {
retorna 1 / valor
}
tente {
dividir(0)
} pegue (erro) {
escreva("tratado")
}
Ver exemplo completo e contrato de teste no GitHub
Experimente: 11_ctfe_contrato
// A otimização não pode remover a validação de inteiro, nem em funções puras.
//>puro
funcao incrementar(valor: inteiro) {
retorna valor + 1
}
escreva(incrementar(2.5))
Ver exemplo completo e contrato de teste no GitHub
Se uma função @puro ultrapassar o limite de passos na compilação ou lançar erro, o CGD simplesmente mantém a chamada normal em runtime. A sintaxe antiga //>puro continua funcionando por compatibilidade.