Remove loop lowering setup in favour of custom compilation paths for for/while loops

Author: rkalis

packages/cashc/src/ast/AST.ts

@@ -206,6 +206,8 @@ export class WhileNode extends ControlStatementNode {
 }
 
 export class ForNode extends ControlStatementNode {
+  symbolTable?: SymbolTable;
+
   constructor(
     public init: VariableDefinitionNode | AssignNode,
     public condition: ExpressionNode,

packages/cashc/src/compiler.ts

@@ -12,7 +12,6 @@ import CashScriptParser from './grammar/CashScriptParser.js';
 import SymbolTableTraversal from './semantic/SymbolTableTraversal.js';
 import TypeCheckTraversal from './semantic/TypeCheckTraversal.js';
 import EnsureFinalRequireTraversal from './semantic/EnsureFinalRequireTraversal.js';
-import LoopLoweringTraversal from './semantic/LoopLoweringTraversal.js';
 
 export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = {
   enforceFunctionParameterTypes: true,
@@ -24,9 +23,6 @@ export function compileString(code: string, compilerOptions: CompilerOptions = {
   // Lexing + parsing
   let ast = parseCode(code);
 
-  // Loop lowering
-  ast = ast.accept(new LoopLoweringTraversal()) as Ast;
-
   // Semantic analysis
   ast = ast.accept(new SymbolTableTraversal()) as Ast;
   ast = ast.accept(new TypeCheckTraversal()) as Ast;

packages/cashc/src/generation/GenerateTargetTraversal.ts

@@ -49,6 +49,8 @@ import {
   ConsoleStatementNode,
   SliceNode,
   DoWhileNode,
+  WhileNode,
+  ForNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import { GlobalFunction, Class } from '../ast/Globals.js';
@@ -450,6 +452,69 @@ export default class GenerateTargetTraversalWithLocation extends AstTraversal {
     return node;
   }
 
+  visitWhile(node: WhileNode): Node {
+    this.scopeDepth += 1;
+    this.emit(Op.OP_BEGIN, { location: node.location, positionHint: PositionHint.START });
+
+    node.condition = this.visit(node.condition);
+    this.emit(Op.OP_DUP, { location: node.condition.location, positionHint: PositionHint.END });
+    this.pushToStack('(value)');
+    this.emit(Op.OP_TOALTSTACK, { location: node.condition.location, positionHint: PositionHint.END });
+    this.popFromStack();
+
+    this.popFromStack();
+    this.emit(Op.OP_IF, { location: node.block.location, positionHint: PositionHint.START });
+
+    const bodyStackDepth = this.stack.length;
+    node.block = this.visit(node.block) as BlockNode;
+    this.removeScopedVariables(bodyStackDepth, node.block);
+
+    this.emit(Op.OP_ENDIF, { location: node.block.location, positionHint: PositionHint.END });
+    this.emit(Op.OP_FROMALTSTACK, { location: node.block.location, positionHint: PositionHint.END });
+    this.pushToStack('(value)');
+    this.emit(Op.OP_NOT, { location: node.location, positionHint: PositionHint.END });
+    this.emit(Op.OP_UNTIL, { location: node.location, positionHint: PositionHint.END });
+    this.popFromStack();
+
+    this.scopeDepth -= 1;
+
+    return node;
+  }
+
+  visitFor(node: ForNode): Node {
+    const forScopeStackDepth = this.stack.length;
+    node.init = this.visit(node.init) as VariableDefinitionNode | AssignNode;
+
+    this.scopeDepth += 1;
+    this.emit(Op.OP_BEGIN, { location: node.location, positionHint: PositionHint.START });
+
+    node.condition = this.visit(node.condition);
+    this.emit(Op.OP_DUP, { location: node.condition.location, positionHint: PositionHint.END });
+    this.pushToStack('(value)');
+    this.emit(Op.OP_TOALTSTACK, { location: node.condition.location, positionHint: PositionHint.END });
+    this.popFromStack();
+
+    this.popFromStack();
+    this.emit(Op.OP_IF, { location: node.block.location, positionHint: PositionHint.START });
+
+    const bodyStackDepth = this.stack.length;
+    node.block = this.visit(node.block) as BlockNode;
+    node.update = this.visit(node.update) as AssignNode;
+    this.removeScopedVariables(bodyStackDepth, node.block);
+
+    this.emit(Op.OP_ENDIF, { location: node.block.location, positionHint: PositionHint.END });
+    this.emit(Op.OP_FROMALTSTACK, { location: node.block.location, positionHint: PositionHint.END });
+    this.pushToStack('(value)');
+    this.emit(Op.OP_NOT, { location: node.location, positionHint: PositionHint.END });
+    this.emit(Op.OP_UNTIL, { location: node.location, positionHint: PositionHint.END });
+    this.popFromStack();
+
+    this.scopeDepth -= 1;
+    this.removeScopedVariables(forScopeStackDepth, node);
+
+    return node;
+  }
+
   removeScopedVariables(depthBeforeScope: number, node: Node): void {
     const dropCount = this.stack.length - depthBeforeScope;
     for (let i = 0; i < dropCount; i += 1) {

packages/cashc/src/semantic/EnsureFinalRequireTraversal.ts

@@ -8,6 +8,8 @@ import {
   BranchNode,
   ConsoleStatementNode,
   DoWhileNode,
+  WhileNode,
+  ForNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import { EmptyContractError, EmptyFunctionError, FinalRequireStatementError } from '../Errors.js';
@@ -51,8 +53,12 @@ function ensureFinalStatementIsRequire(statements: StatementNode[] = []): void {
     return;
   }
 
-  // TODO: Revisit this later, for now we allow do-while loops to not have a require() at the end
-  if (finalStatement instanceof DoWhileNode) {
+  // TODO: Revisit this later, for now we allow loops to not have a require() at the end
+  if (
+    finalStatement instanceof DoWhileNode
+    || finalStatement instanceof WhileNode
+    || finalStatement instanceof ForNode
+  ) {
     // ensureFinalStatementIsRequire(finalStatement.block.statements);
     return;
   }

packages/cashc/src/semantic/LoopLoweringTraversal.ts

@@ -14,6 +14,7 @@ import {
   TupleAssignmentNode,
   ConsoleStatementNode,
   ConsoleParameterNode,
+  ForNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import { SymbolTable, Symbol, SymbolType } from '../ast/SymbolTable.js';
@@ -98,6 +99,24 @@ export default class SymbolTableTraversal extends AstTraversal {
     return node;
   }
 
+  visitFor(node: ForNode): Node {
+    node.symbolTable = new SymbolTable(this.symbolTables[0]);
+    this.symbolTables.unshift(node.symbolTable);
+
+    node.init = this.visit(node.init) as VariableDefinitionNode | AssignNode;
+    node.condition = this.visit(node.condition);
+    node.update = this.visit(node.update) as AssignNode;
+    node.block = this.visit(node.block);
+
+    const unusedSymbols = node.symbolTable.unusedSymbols();
+    if (unusedSymbols.length !== 0) {
+      throw new UnusedVariableError(unusedSymbols[0]);
+    }
+
+    this.symbolTables.shift();
+    return node;
+  }
+
   visitVariableDefinition(node: VariableDefinitionNode): Node {
     if (this.symbolTables[0].get(node.name)) {
       throw new VariableRedefinitionError(node);

packages/cashc/src/semantic/SymbolTableTraversal.ts

@@ -29,6 +29,8 @@ import {
   SliceNode,
   IntLiteralNode,
   DoWhileNode,
+  WhileNode,
+  ForNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import {
@@ -113,6 +115,30 @@ export default class TypeCheckTraversal extends AstTraversal {
     return node;
   }
 
+  visitWhile(node: WhileNode): Node {
+    node.condition = this.visit(node.condition);
+    node.block = this.visit(node.block);
+
+    if (!implicitlyCastable(node.condition.type, PrimitiveType.BOOL)) {
+      throw new TypeError(node.condition, node.condition.type, PrimitiveType.BOOL);
+    }
+
+    return node;
+  }
+
+  visitFor(node: ForNode): Node {
+    node.init = this.visit(node.init) as AssignNode | VariableDefinitionNode;
+    node.condition = this.visit(node.condition);
+    node.update = this.visit(node.update) as AssignNode;
+    node.block = this.visit(node.block);
+
+    if (!implicitlyCastable(node.condition.type, PrimitiveType.BOOL)) {
+      throw new TypeError(node.condition, node.condition.type, PrimitiveType.BOOL);
+    }
+
+    return node;
+  }
+
   visitCast(node: CastNode): Node {
     node.expression = this.visit(node.expression);