Constant Folding

​

What is Constant Folding?

• Reduces runtime computation
• Makes code easier to read in some cases
• Can help with further optimizations
• Preserves program behavior

​

ConstantFolder Class

​

Usage

using Loretta.CodeAnalysis.Lua;
using Loretta.CodeAnalysis.Lua.Experimental;

var code = @"
local x = 10 + 5
local y = 'Hello' .. ' ' .. 'World'
local z = 2 ^ 8
local w = not false
";

var tree = LuaSyntaxTree.ParseText(code);
var root = tree.GetRoot();

// Apply constant folding
var folded = root.ConstantFold(ConstantFoldingOptions.Default);

Console.WriteLine(folded.ToFullString());
// Output:
// local x = 15
// local y = 'Hello World'
// local z = 256
// local w = true

​

ConstantFoldingOptions

​

Available Options

​

Presets

var folded = root.ConstantFold(ConstantFoldingOptions.Default);

var folded = root.ConstantFold(ConstantFoldingOptions.All);

​

Custom Options

var options = new ConstantFoldingOptions(
    ExtractNumbersFromStrings: true
);

var folded = root.ConstantFold(options);

​

Supported Operations

​

Arithmetic Operations

• Addition: 1 + 2 → 3
• Subtraction: 5 - 3 → 2
• Multiplication: 4 * 5 → 20
• Division: 10 / 2 → 5
• Modulo: 10 % 3 → 1
• Exponentiation: 2 ^ 3 → 8
• Unary minus: -5 → -5

​

Bitwise Operations (Lua 5.3+)

• Bitwise OR: 5 | 3 → 7
• Bitwise AND: 5 & 3 → 1
• Bitwise XOR: 5 ~ 3 → 6
• Bitwise NOT: ~5 → -6
• Left shift: 1 << 3 → 8
• Right shift: 8 >> 2 → 2

​

String Operations

• Concatenation: "hello" .. " " .. "world" → "hello world"
• Length: #"hello" → 5
• Boolean concatenation: "value: " .. true → "value: true"

​

Comparison Operations

• Equality: 5 == 5 → true
• Inequality: 5 ~= 3 → true
• Less than: 3 < 5 → true
• Less than or equal: 3 <= 3 → true
• Greater than: 5 > 3 → true
• Greater than or equal: 5 >= 5 → true

​

Logical Operations

• NOT: not false → true
• AND: true and 5 → 5, false and 5 → false
• OR: true or 5 → true, false or 5 → 5

​

Table Operations

• Member access on constant tables: {x = 5}.x → 5
• Element access on constant tables: {["key"] = 10}["key"] → 10

​

Other Optimizations

• Removes redundant parentheses: ((5)) → 5

​

Before and After Example

var code = @"
local PI = 3.14159
local radius = 10
local area = PI * (radius ^ 2)
local message = 'The area is: ' .. 'approximately'
local isValid = not (radius < 0)
local flags = 0x01 | 0x02 | 0x04
";

var tree = LuaSyntaxTree.ParseText(code);
var folded = tree.GetRoot().ConstantFold(ConstantFoldingOptions.Default);

Console.WriteLine(folded.ToFullString());

local PI = 3.14159
local radius = 10
local area = PI * (radius ^ 2)
local message = 'The area is: ' .. 'approximately'
local isValid = not (radius < 0)
local flags = 0x01 | 0x02 | 0x04

local PI = 3.14159
local radius = 10
local area = PI * 100
local message = 'The area is: approximately'
local isValid = not false
local flags = 7

​

Limitations

​

Special Values

• NaN and Infinity: Operations that produce NaN or Infinity are not folded to preserve safety
• Example: 0 / 0 is not folded because it produces NaN

​

Dynamic Values

• Function calls cannot be folded: math.sqrt(16) remains as-is
• Variable references cannot be folded: x + 1 where x is a variable
• Indexing non-constant tables: someTable[key] remains as-is

​

Scope Limitations

• Only literal values and expressions built from literals are folded
• No cross-statement or cross-function analysis is performed

​

Type Coercion

• String-to-number coercion requires ExtractNumbersFromStrings option
• Complex type coercions may not be supported

​

When to Use Constant Folding

​

Good Use Cases

• Code generators: Pre-compute values in generated code
• Optimization pipelines: As part of a larger optimization strategy
• Dead code elimination: Simplify conditional expressions for further analysis
• Build-time optimization: Optimize code during build/deployment

​

When to Avoid

• Debugging: Folded constants can make debugging harder
• Source mapping: May complicate source map generation
• Readability: Sometimes the original expression is clearer than the folded value
• Float precision: Be cautious with floating-point operations where precision matters

​

See Also

• Minifier - Reduce code size and obfuscate variable names
• Experimental Package Overview - Learn about other experimental features