Implement statement sequence for the CSE machine (#1575)

* Creation of StatementSequence, custom Node type and changes in CSE machine

* fix formatting

* Implement AST transformer and  transformation

* formatting

* bug fix #1

* limit places where transformed tree is run

* Sent statementSequence transformer to utils + transform happens immediately before execution

* format

* remove debug

* i am actually so stupid

* Completion of CSE machine handling of StatementSequence

* Clousre creation now accounts for StatementSequence

* hasBreak/Continue/Return now accounts for StatementSequence

* astToString now works on StatementSequence

* wait this should not be here

* Add Program to StatementSequence transformer + update CSE machine implementation

* minor suggestions from code review

---------

Co-authored-by: Martin Henz <[email protected]>

Author: NhatMinh0208

src/cse-machine/instrCreator.ts

@@ -4,7 +4,7 @@
 
 import * as es from 'estree'
 
-import { Environment } from '../types'
+import { Environment, Node } from '../types'
 import {
   AppInstr,
   ArrLitInstr,
@@ -21,16 +21,12 @@ import {
   WhileInstr
 } from './types'
 
-export const resetInstr = (srcNode: es.Node): Instr => ({
+export const resetInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.RESET,
   srcNode
 })
 
-export const whileInstr = (
-  test: es.Expression,
-  body: es.Statement,
-  srcNode: es.Node
-): WhileInstr => ({
+export const whileInstr = (test: es.Expression, body: es.Statement, srcNode: Node): WhileInstr => ({
   instrType: InstrType.WHILE,
   test,
   body,
@@ -42,7 +38,7 @@ export const forInstr = (
   test: es.Expression,
   update: es.Expression,
   body: es.Statement,
-  srcNode: es.Node
+  srcNode: Node
 ): ForInstr => ({
   instrType: InstrType.FOR,
   init,
@@ -56,7 +52,7 @@ export const assmtInstr = (
   symbol: string,
   constant: boolean,
   declaration: boolean,
-  srcNode: es.Node
+  srcNode: Node
 ): AssmtInstr => ({
   instrType: InstrType.ASSIGNMENT,
   symbol,
@@ -65,19 +61,19 @@ export const assmtInstr = (
   srcNode
 })
 
-export const unOpInstr = (symbol: es.UnaryOperator, srcNode: es.Node): UnOpInstr => ({
+export const unOpInstr = (symbol: es.UnaryOperator, srcNode: Node): UnOpInstr => ({
   instrType: InstrType.UNARY_OP,
   symbol,
   srcNode
 })
 
-export const binOpInstr = (symbol: es.BinaryOperator, srcNode: es.Node): BinOpInstr => ({
+export const binOpInstr = (symbol: es.BinaryOperator, srcNode: Node): BinOpInstr => ({
   instrType: InstrType.BINARY_OP,
   symbol,
   srcNode
 })
 
-export const popInstr = (srcNode: es.Node): Instr => ({ instrType: InstrType.POP, srcNode })
+export const popInstr = (srcNode: Node): Instr => ({ instrType: InstrType.POP, srcNode })
 
 export const appInstr = (numOfArgs: number, srcNode: es.CallExpression): AppInstr => ({
   instrType: InstrType.APPLICATION,
@@ -88,67 +84,67 @@ export const appInstr = (numOfArgs: number, srcNode: es.CallExpression): AppInst
 export const branchInstr = (
   consequent: es.Expression | es.Statement,
   alternate: es.Expression | es.Statement | null | undefined,
-  srcNode: es.Node
+  srcNode: Node
 ): BranchInstr => ({
   instrType: InstrType.BRANCH,
   consequent,
   alternate,
   srcNode
 })
 
-export const envInstr = (env: Environment, srcNode: es.Node): EnvInstr => ({
+export const envInstr = (env: Environment, srcNode: Node): EnvInstr => ({
   instrType: InstrType.ENVIRONMENT,
   env,
   srcNode
 })
 
-export const arrLitInstr = (arity: number, srcNode: es.Node): ArrLitInstr => ({
+export const arrLitInstr = (arity: number, srcNode: Node): ArrLitInstr => ({
   instrType: InstrType.ARRAY_LITERAL,
   arity,
   srcNode
 })
 
-export const arrAccInstr = (srcNode: es.Node): Instr => ({
+export const arrAccInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.ARRAY_ACCESS,
   srcNode
 })
 
-export const arrAssmtInstr = (srcNode: es.Node): Instr => ({
+export const arrAssmtInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.ARRAY_ASSIGNMENT,
   srcNode
 })
 
-export const markerInstr = (srcNode: es.Node): Instr => ({
+export const markerInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.MARKER,
   srcNode
 })
 
-export const contInstr = (srcNode: es.Node): Instr => ({
+export const contInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.CONTINUE,
   srcNode
 })
 
-export const contMarkerInstr = (srcNode: es.Node): Instr => ({
+export const contMarkerInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.CONTINUE_MARKER,
   srcNode
 })
 
-export const breakInstr = (srcNode: es.Node): Instr => ({
+export const breakInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.BREAK,
   srcNode
 })
 
-export const breakMarkerInstr = (srcNode: es.Node): Instr => ({
+export const breakMarkerInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.BREAK_MARKER,
   srcNode
 })
 
-export const genContInstr = (srcNode: es.Node): GenContInstr => ({
+export const genContInstr = (srcNode: Node): GenContInstr => ({
   instrType: InstrType.GENERATE_CONT,
   srcNode
 })
 
-export const resumeContInstr = (srcNode: es.Node): ResumeContInstr => ({
+export const resumeContInstr = (srcNode: Node): ResumeContInstr => ({
   instrType: InstrType.RESUME_CONT,
   srcNode
 })

src/cse-machine/interpreter.ts

@@ -19,12 +19,13 @@ import { initModuleContext, loadModuleBundle } from '../modules/moduleLoader'
 import { ImportTransformOptions } from '../modules/moduleTypes'
 import { checkEditorBreakpoints } from '../stdlib/inspector'
 import { checkProgramForUndefinedVariables } from '../transpiler/transpiler'
-import { Context, ContiguousArrayElements, RawBlockStatement, Result, Value } from '../types'
+import { Context, ContiguousArrayElements, Result, StatementSequence, Value } from '../types'
 import assert from '../utils/assert'
 import { filterImportDeclarations } from '../utils/ast/helpers'
 import * as ast from '../utils/astCreator'
 import { evaluateBinaryExpression, evaluateUnaryExpression } from '../utils/operators'
 import * as rttc from '../utils/rttc'
+import * as seq from '../utils/statementSeqTransform'
 import {
   Continuation,
   getContinuationControl,
@@ -72,7 +73,6 @@ import {
   isBlockStatement,
   isInstr,
   isNode,
-  isRawBlockStatement,
   isSimpleFunction,
   popEnvironment,
   pushEnvironment,
@@ -95,7 +95,7 @@ type CmdEvaluator = (
  * It contains syntax tree nodes or instructions.
  */
 export class Control extends Stack<ControlItem> {
-  public constructor(program?: es.Program) {
+  public constructor(program?: es.Program | StatementSequence) {
     super()
 
     // Load program into control stack
@@ -109,20 +109,18 @@ export class Control extends Stack<ControlItem> {
 
   /**
    * Before pushing block statements on the control stack, we check if the block statement has any declarations.
-   * If not (and its not a raw block statement), instead of pushing the entire block, just the body is pushed since the block is not adding any value.
+   * If not, the block is converted to a StatementSequence.
    * @param items The items being pushed on the control.
-   * @returns The same set of control items, but with block statements without declarations simplified.
+   * @returns The same set of control items, but with block statements without declarations converted to StatementSequences.
+   * NOTE: this function handles any case where StatementSequence has to be converted back into BlockStatement due to type issues
    */
   private static simplifyBlocksWithoutDeclarations(...items: ControlItem[]): ControlItem[] {
     const itemsNew: ControlItem[] = []
     items.forEach(item => {
-      if (
-        isNode(item) &&
-        isBlockStatement(item) &&
-        !hasDeclarations(item) &&
-        !isRawBlockStatement(item)
-      ) {
-        itemsNew.push(...Control.simplifyBlocksWithoutDeclarations(...handleSequence(item.body)))
+      if (isNode(item) && isBlockStatement(item) && !hasDeclarations(item)) {
+        // Push block body as statement sequence
+        const seq: StatementSequence = ast.statementSequence(item.body, item.loc)
+        itemsNew.push(seq)
       } else {
         itemsNew.push(item)
       }
@@ -169,6 +167,7 @@ export function evaluate(program: es.Program, context: Context, options: IOption
     context.errors.push(error)
     return new CseError(error)
   }
+  seq.transform(program)
 
   try {
     context.runtime.isRunning = true
@@ -311,8 +310,11 @@ export function* generateCSEMachineStateStream(
 
   let command = control.peek()
 
-  // First node will be a Program
-  context.runtime.nodes.unshift(command as es.Program)
+  // Push first node to be evaluated into context.
+  // The typeguard is there to guarantee that we are pushing a node (which should always be the case)
+  if (command && isNode(command)) {
+    context.runtime.nodes.unshift(command)
+  }
 
   while (command) {
     // Return to capture a snapshot of the control and stash after the target step count is reached
@@ -369,7 +371,7 @@ export function* generateCSEMachineStateStream(
 
 /**
  * Dictionary of functions which handle the logic for the response of the three registers of
- * the ASE machine to each ControlItem.
+ * the CSE machine to each ControlItem.
  */
 const cmdEvaluators: { [type: string]: CmdEvaluator } = {
   /**
@@ -400,31 +402,17 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       const next = command.body[0]
       cmdEvaluators[next.type](next, context, control, stash, isPrelude)
     } else {
-      // Push raw block statement
-      const rawCopy: RawBlockStatement = {
-        type: 'BlockStatement',
-        range: command.range,
-        loc: command.loc,
-        body: command.body,
-        isRawBlock: 'true'
-      }
-      control.push(rawCopy)
+      // Push block body as statement sequence
+      const seq: StatementSequence = ast.statementSequence(command.body, command.loc)
+      control.push(seq)
     }
   },
 
   BlockStatement: function (command: es.BlockStatement, context: Context, control: Control) {
-    if (isRawBlockStatement(command)) {
-      // Raw block statement: unpack and push body
-      // Push block body only
-      control.push(...handleSequence(command.body))
-      return
-    }
-    // Normal block statement: do environment setup
     // To restore environment after block ends
     // If there is an env instruction on top of the stack, or if there are no declarations
     // we do not need to push another one
-    // The no declarations case is handled by Control :: simplifyBlocksWithoutDeclarations, so no blockStatement node
-    // without declarations should end up here.
+    // The no declarations case is handled at the transform stage, so no blockStatement node without declarations should end up here.
     const next = control.peek()
     // Push ENVIRONMENT instruction if needed
     if (!next || !(isInstr(next) && next.instrType === InstrType.ENVIRONMENT)) {
@@ -435,15 +423,27 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     declareFunctionsAndVariables(context, command, environment)
     pushEnvironment(context, environment)
 
-    // Push raw block statement
-    const rawCopy: RawBlockStatement = {
-      type: 'BlockStatement',
-      range: command.range,
-      loc: command.loc,
-      body: command.body,
-      isRawBlock: 'true'
+    // Push block body as statement sequence
+    const seq: StatementSequence = ast.statementSequence(command.body, command.loc)
+    control.push(seq)
+  },
+
+  StatementSequence: function (
+    command: StatementSequence,
+    context: Context,
+    control: Control,
+    stash: Stash,
+    isPrelude: boolean
+  ) {
+    if (command.body.length == 1) {
+      // If sequence only consists of one statement, evaluate it immediately
+      const next = command.body[0]
+      cmdEvaluators[next.type](next, context, control, stash, isPrelude)
+    } else {
+      // unpack and push individual nodes in body
+      control.push(...handleSequence(command.body))
     }
-    control.push(rawCopy)
+    return
   },
 
   WhileStatement: function (
@@ -981,7 +981,7 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     // Value is a function
     // Check for number of arguments mismatch error
     checkNumberOfArguments(context, func, args, command.srcNode)
-    // Directly stash result of applying pre-built functions without the ASE machine.
+    // Directly stash result of applying pre-built functions without the CSE machine.
     try {
       const result = func(...args)
       stash.push(result)

src/cse-machine/types.ts

@@ -1,6 +1,6 @@
 import * as es from 'estree'
 
-import { Environment } from '../types'
+import { Environment, Node } from '../types'
 
 export enum InstrType {
   RESET = 'Reset',
@@ -28,7 +28,7 @@ export enum InstrType {
 
 interface BaseInstr {
   instrType: InstrType
-  srcNode: es.Node
+  srcNode: Node
 }
 
 export interface WhileInstr extends BaseInstr {
@@ -90,7 +90,7 @@ export type Instr =
   | GenContInstr
   | ResumeContInstr
 
-export type ControlItem = es.Node | Instr
+export type ControlItem = Node | Instr
 
 // Special class that cannot be found on the stash so is safe to be used
 // as an indicator of a breakpoint from running the CSE machine