fix: very simple constant propagation for obvious cases

src/ast/clone.ts

@@ -1,6 +1,6 @@
-import { AstNode } from "./ast";
 import { FactoryAst } from "./ast-helpers";
 import { throwInternalCompilerError } from "../error/errors";
+import { AstNode } from "./ast";
 
 export function cloneNode<T extends AstNode>(
     src: T,
@@ -17,6 +17,25 @@ export function cloneNode<T extends AstNode>(
             return cloneNode(src);
         } else if (src.kind === "string") {
             return cloneNode(src);
+        } else if (src.kind === "address") {
+            // The actual address value src.value is immutable (it freezes its fields in its constructor)
+            // So, there is no need to make a copy of the value
+            return cloneNode(src);
+        } else if (src.kind === "cell") {
+            // The actual address value src.value is immutable (it freezes its fields in its constructor)
+            // So, there is no need to make a copy of the value
+            return cloneNode(src);
+        } else if (src.kind === "simplified_string") {
+            return cloneNode(src);
+        } else if (src.kind === "slice") {
+            // This will make a copy of the slice from the point it is
+            // currently reading (this is compatible with the way equality works for slices)
+            return cloneNode({ ...src, value: src.value.clone() });
+        } else if (src.kind === "struct_value") {
+            return cloneNode({
+                ...src,
+                args: src.args.map(recurse),
+            });
         } else if (src.kind === "statement_assign") {
             return cloneNode({
                 ...src,
@@ -55,6 +74,11 @@ export function cloneNode<T extends AstNode>(
                 ...src,
                 initializer: recurse(src.initializer),
             });
+        } else if (src.kind === "struct_field_value") {
+            return cloneNode({
+                ...src,
+                initializer: recurse(src.initializer),
+            });
         } else if (src.kind === "statement_expression") {
             return cloneNode({
                 ...src,

src/ast/util.ts

@@ -3,33 +3,71 @@ import * as A from "./ast";
 import { isLiteral, FactoryAst } from "./ast-helpers";
 import { dummySrcInfo, SrcInfo } from "../grammar";
 
-export const getAstUtil = ({ createNode }: FactoryAst) => {
+export const getAstUtil = ({ createNode, cloneNode }: FactoryAst) => {
+    /**
+     * @deprecated, since it uses dummySrcInfo. Use makeUnaryExpressionLoc instead.
+     *
+     */
     function makeUnaryExpression(
         op: A.AstUnaryOperation,
         operand: A.AstExpression,
-    ): A.AstExpression {
+    ): A.AstOpUnary {
         const result = createNode({
             kind: "op_unary",
             op: op,
             operand: operand,
             loc: dummySrcInfo,
         });
-        return result as A.AstExpression;
+        return result as A.AstOpUnary;
     }
 
+    /**
+     * @deprecated, since it uses dummySrcInfo. Use makeBinaryExpressionLoc instead.
+     *
+     */
     function makeBinaryExpression(
         op: A.AstBinaryOperation,
         left: A.AstExpression,
         right: A.AstExpression,
-    ): A.AstExpression {
+    ): A.AstOpBinary {
         const result = createNode({
             kind: "op_binary",
             op: op,
             left: left,
             right: right,
             loc: dummySrcInfo,
         });
-        return result as A.AstExpression;
+        return result as A.AstOpBinary;
+    }
+
+    function makeUnaryExpressionLoc(
+        op: A.AstUnaryOperation,
+        operand: A.AstExpression,
+        loc: SrcInfo,
+    ): A.AstOpUnary {
+        const result = createNode({
+            kind: "op_unary",
+            op: op,
+            operand: operand,
+            loc,
+        });
+        return result as A.AstOpUnary;
+    }
+
+    function makeBinaryExpressionLoc(
+        op: A.AstBinaryOperation,
+        left: A.AstExpression,
+        right: A.AstExpression,
+        loc: SrcInfo,
+    ): A.AstOpBinary {
+        const result = createNode({
+            kind: "op_binary",
+            op: op,
+            left: left,
+            right: right,
+            loc,
+        });
+        return result as A.AstOpBinary;
     }
 
     function makeNumberLiteral(n: bigint, loc: SrcInfo): A.AstNumber {
@@ -130,7 +168,75 @@ export const getAstUtil = ({ createNode }: FactoryAst) => {
         return result as A.AstStructValue;
     }
 
+    function makeAssignStatement(
+        path: A.AstExpression,
+        expression: A.AstExpression,
+        loc: SrcInfo,
+    ): A.AstStatementAssign {
+        const result = createNode({
+            kind: "statement_assign",
+            path,
+            expression,
+            loc,
+        });
+        return result as A.AstStatementAssign;
+    }
+
+    function makeMethodCall(
+        self: A.AstExpression,
+        method: A.AstId,
+        args: A.AstExpression[],
+        loc: SrcInfo,
+    ): A.AstMethodCall {
+        const result = createNode({
+            kind: "method_call",
+            self,
+            method,
+            args,
+            loc,
+        });
+        return result as A.AstMethodCall;
+    }
+
+    function makeStaticCall(
+        fun: A.AstId,
+        args: A.AstExpression[],
+        loc: SrcInfo,
+    ): A.AstStaticCall {
+        const result = createNode({
+            kind: "static_call",
+            function: fun,
+            args,
+            loc,
+        });
+        return result as A.AstStaticCall;
+    }
+
+    function makeInitOf(
+        contract: A.AstId,
+        args: A.AstExpression[],
+        loc: SrcInfo,
+    ): A.AstInitOf {
+        const result = createNode({
+            kind: "init_of",
+            contract,
+            args,
+            loc,
+        });
+        return result as A.AstInitOf;
+    }
+
+    function changeLocationOfLiteral(
+        expr: A.AstLiteral,
+        loc: SrcInfo,
+    ): A.AstLiteral {
+        return cloneNode({ ...expr, loc });
+    }
+
     return {
+        changeLocationOfLiteral,
+        makeUnaryExpressionLoc,
+        makeBinaryExpressionLoc,
         makeUnaryExpression,
         makeBinaryExpression,
         makeNumberLiteral,
@@ -142,6 +248,10 @@ export const getAstUtil = ({ createNode }: FactoryAst) => {
         makeAddressLiteral,
         makeStructFieldValue,
         makeStructValue,
+        makeAssignStatement,
+        makeMethodCall,
+        makeStaticCall,
+        makeInitOf,
     };
 };
 

src/generator/writers/writeExpression.ts

@@ -34,7 +34,6 @@ import { ops } from "./ops";
 import { writeCastedExpression } from "./writeFunction";
 import { isLvalue } from "../../types/resolveStatements";
 import { evalConstantExpression } from "../../optimizer/constEval";
-import { getAstUtil } from "../../ast/util";
 import {
     eqNames,
     getAstFactory,
@@ -176,12 +175,11 @@ export function writeExpression(
     //    return writeValue(f, wCtx);
     // }
     try {
-        const util = getAstUtil(getAstFactory());
         // Let us put a limit of 2 ^ 12 = 4096 iterations on loops to increase compiler responsiveness.
         // If a loop takes more than such number of iterations, the interpreter will fail evaluation.
         // I think maxLoopIterations should be a command line option in case a user wants to wait more
         // during evaluation.
-        const value = evalConstantExpression(f, wCtx.ctx, util, {
+        const value = evalConstantExpression(f, wCtx.ctx, getAstFactory(), {
             maxLoopIterations: 2n ** 12n,
         });
         return writeValue(value, wCtx);

src/optimizer/constEval.ts

@@ -1,11 +1,11 @@
 import { CompilerContext } from "../context/context";
 import * as A from "../ast/ast";
-import { isLiteral } from "../ast/ast-helpers";
+import { FactoryAst, isLiteral } from "../ast/ast-helpers";
 import {
     TactConstEvalError,
     throwInternalCompilerError,
 } from "../error/errors";
-import { AstUtil } from "../ast/util";
+import { getAstUtil } from "../ast/util";
 import { ExpressionTransformer } from "./types";
 import { StandardOptimizer } from "./standardOptimizer";
 import {
@@ -34,7 +34,9 @@ class PartiallyEvaluatedTree extends Error {
     }
 }
 
-export const getOptimizer = (util: AstUtil) => {
+export const getOptimizer = (astF: FactoryAst) => {
+    const util = getAstUtil(astF);
+
     // The optimizer that applies the rewriting rules during partial evaluation.
     // For the moment we use an optimizer that respects overflows.
     const optimizer: ExpressionTransformer = new StandardOptimizer(util);
@@ -134,7 +136,7 @@ export const getOptimizer = (util: AstUtil) => {
         ctx: CompilerContext,
         interpreterConfig?: InterpreterConfig,
     ): A.AstExpression {
-        const interpreter = new Interpreter(util, ctx, interpreterConfig);
+        const interpreter = new Interpreter(astF, ctx, interpreterConfig);
         switch (ast.kind) {
             case "id":
                 try {
@@ -212,10 +214,10 @@ export const getOptimizer = (util: AstUtil) => {
 export function evalConstantExpression(
     ast: A.AstExpression,
     ctx: CompilerContext,
-    util: AstUtil,
+    astF: FactoryAst,
     interpreterConfig?: InterpreterConfig,
 ): A.AstLiteral {
-    const interpreter = new Interpreter(util, ctx, interpreterConfig);
+    const interpreter = new Interpreter(astF, ctx, interpreterConfig);
     const result = interpreter.interpretExpression(ast);
     return result;
 }