Update ast helpers

Author: leeyi45

src/cse-machine/interpreter.ts

@@ -602,6 +602,7 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
                         command.loc
                       )
                     ],
+                    'const',
                     command.loc
                   ),
                   ast.blockStatement(
@@ -614,6 +615,7 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
                             command.loc
                           )
                         ],
+                        'const',
                         command.loc
                       ),
                       command.body

src/modules/preprocessor/index.ts

@@ -96,21 +96,21 @@ const preprocessFileImports = async (
       context,
       options?.importOptions
     )
+
+    const program = bundler(programs, entrypointFilePath, topoOrder, context)
+    return {
+      ok: true,
+      program,
+      files: linkerResult.files,
+      verboseErrors: linkerResult.verboseErrors
+    }
   } catch (error) {
     context.errors.push(error)
     return {
       ok: false,
       verboseErrors: linkerResult.verboseErrors
     }
   }
-
-  const program = bundler(programs, entrypointFilePath, topoOrder, context)
-  return {
-    ok: true,
-    program,
-    files: linkerResult.files,
-    verboseErrors: linkerResult.verboseErrors
-  }
 }
 
 export default preprocessFileImports

src/modules/preprocessor/linker.ts

@@ -139,7 +139,7 @@ export default async function parseProgramsAndConstructImportGraph(
     let statement: es.Node | null = null
 
     if (!programs[entrypointFilePath]) {
-      if (entrypointFileText == undefined) {
+      if (entrypointFileText === undefined) {
         // non-existent entrypoint
         return false
       }

src/utils/ast/astCreator.ts

@@ -8,9 +8,6 @@ import {
   type StatementSequence
 } from '../../types'
 
-export const getVariableDeclarationName = (decl: es.VariableDeclaration) =>
-  (decl.declarations[0].id as es.Identifier).name
-
 export const locationDummyNode = (line: number, column: number, source: string | null) =>
   literal('Dummy', { start: { line, column }, end: { line, column }, source })
 
@@ -85,18 +82,18 @@ export const declaration = (
   kind: AllowedDeclarations,
   init: es.Expression,
   loc?: es.SourceLocation | null
-): es.VariableDeclaration => ({
-  type: 'VariableDeclaration',
-  declarations: [
-    {
-      type: 'VariableDeclarator',
-      id: identifier(name),
-      init
-    }
-  ],
-  kind,
-  loc
-})
+) =>
+  variableDeclaration(
+    [
+      {
+        type: 'VariableDeclarator',
+        id: identifier(name),
+        init
+      }
+    ],
+    kind,
+    loc
+  )
 
 export const constantDeclaration = (
   name: string,
@@ -376,10 +373,11 @@ export const arrowFunctionExpression = (
 
 export const variableDeclaration = (
   declarations: es.VariableDeclarator[],
+  kind: es.VariableDeclaration['kind'] = 'const',
   loc?: es.SourceLocation | null
 ): es.VariableDeclaration => ({
   type: 'VariableDeclaration',
-  kind: 'const',
+  kind,
   declarations,
   loc
 })

src/utils/ast/helpers.ts

@@ -3,7 +3,7 @@ import type es from 'estree'
 import assert from '../assert'
 import { simple } from '../walkers'
 import { ArrayMap } from '../dict'
-import { isImportDeclaration, isVariableDeclaration } from './typeGuards'
+import { isIdentifier, isImportDeclaration, isVariableDeclaration } from './typeGuards'
 
 export function getModuleDeclarationSource(
   node: Exclude<es.ModuleDeclaration, es.ExportDefaultDeclaration>
@@ -71,10 +71,27 @@ export function getIdsFromDeclaration(decl: es.Declaration, allowNull?: boolean)
   return rawIds
 }
 
+export function getSourceVariableDeclaration(decl: es.VariableDeclaration) {
+  assert(
+    decl.declarations.length === 1,
+    'Variable Declarations in Source should only have 1 declarator!'
+  )
+
+  const [declaration] = decl.declarations
+  assert(
+    isIdentifier(declaration.id),
+    'Variable Declarations in Source should be declared using an Identifier!'
+  )
+
+  return {
+    id: declaration.id,
+    init: declaration.init!,
+    loc: declaration.loc
+  }
+}
+
 export const getImportedName = (
-  spec:
-    | Exclude<es.ImportDeclaration['specifiers'][number], es.ImportNamespaceSpecifier>
-    | es.ExportSpecifier
+  spec: es.ImportSpecifier | es.ImportDefaultSpecifier | es.ExportSpecifier
 ) => {
   switch (spec.type) {
     case 'ImportDefaultSpecifier':
@@ -85,3 +102,24 @@ export const getImportedName = (
       return spec.local.name
   }
 }
+
+export const speciferToString = (
+  spec: es.ImportSpecifier | es.ImportDefaultSpecifier | es.ExportSpecifier
+) => {
+  switch (spec.type) {
+    case 'ImportSpecifier': {
+      if (spec.imported.name === spec.local.name) {
+        return spec.imported.name
+      }
+      return `${spec.imported.name} as ${spec.local.name}`
+    }
+    case 'ImportDefaultSpecifier':
+      return `default as ${spec.local.name}`
+    case 'ExportSpecifier': {
+      if (spec.local.name === spec.exported.name) {
+        return spec.local.name
+      }
+      return `${spec.local.name} as ${spec.exported.name}`
+    }
+  }
+}

src/validator/__tests__/validator.ts

@@ -1,13 +1,13 @@
-import * as es from 'estree'
+import type es from 'estree'
 
 import { mockContext } from '../../utils/testing/mocks'
 import { parse } from '../../parser/parser'
 import { Chapter, NodeWithInferredType } from '../../types'
-import { getVariableDeclarationName } from '../../utils/ast/astCreator'
 import { stripIndent } from '../../utils/formatters'
 import { expectParsedError } from '../../utils/testing'
 import { simple } from '../../utils/walkers'
 import { validateAndAnnotate } from '../validator'
+import { getSourceVariableDeclaration } from '../../utils/ast/helpers'
 
 export function toValidatedAst(code: string) {
   const context = mockContext(Chapter.SOURCE_1)
@@ -57,7 +57,7 @@ test('testing typability', () => {
   simple(ast, {
     VariableDeclaration(node: NodeWithInferredType<es.VariableDeclaration>) {
       let expectedTypability = ''
-      switch (getVariableDeclarationName(node)) {
+      switch (getSourceVariableDeclaration(node).id.name) {
         case 'a':
         case 'b':
           expectedTypability = 'NotYetTyped'

src/validator/validator.ts

@@ -1,18 +1,18 @@
-import * as es from 'estree'
+import type es from 'estree'
 
 import { ConstAssignment, UndefinedVariable } from '../errors/errors'
 import { NoAssignmentToForVariable } from '../errors/validityErrors'
 import { parse } from '../parser/parser'
-import { Context, Node, NodeWithInferredType } from '../types'
-import { getVariableDeclarationName } from '../utils/ast/astCreator'
+import type { Context, Node, NodeWithInferredType } from '../types'
 import {
   getFunctionDeclarationNamesInProgram,
   getIdentifiersInNativeStorage,
   getIdentifiersInProgram,
   getNativeIds,
-  NativeIds
+  type NativeIds
 } from '../utils/uniqueIds'
-import { ancestor, base, FullWalkerCallback } from '../utils/walkers'
+import { ancestor, base, type FullWalkerCallback } from '../utils/walkers'
+import { getSourceVariableDeclaration } from '../utils/ast/helpers'
 
 class Declaration {
   public accessedBeforeDeclaration: boolean = false
@@ -30,7 +30,7 @@ export function validateAndAnnotate(
     for (const statement of node.body) {
       if (statement.type === 'VariableDeclaration') {
         initialisedIdentifiers.set(
-          getVariableDeclarationName(statement),
+          getSourceVariableDeclaration(statement).id.name,
           new Declaration(statement.kind === 'const')
         )
       } else if (statement.type === 'FunctionDeclaration') {
@@ -64,7 +64,9 @@ export function validateAndAnnotate(
       if (init.type === 'VariableDeclaration') {
         accessedBeforeDeclarationMap.set(
           forStatement,
-          new Map([[getVariableDeclarationName(init), new Declaration(init.kind === 'const')]])
+          new Map([
+            [getSourceVariableDeclaration(init).id.name, new Declaration(init.kind === 'const')]
+          ])
         )
         scopeHasCallExpressionMap.set(forStatement, false)
       }
@@ -105,7 +107,7 @@ export function validateAndAnnotate(
     {
       VariableDeclaration(node: NodeWithInferredType<es.VariableDeclaration>, ancestors: Node[]) {
         const lastAncestor = ancestors[ancestors.length - 2]
-        const name = getVariableDeclarationName(node)
+        const { name } = getSourceVariableDeclaration(node).id
         const accessedBeforeDeclaration = accessedBeforeDeclarationMap
           .get(lastAncestor)!
           .get(name)!.accessedBeforeDeclaration
@@ -180,7 +182,10 @@ export function checkForUndefinedVariables(
     const identifiers = new Set<string>()
     for (const statement of node.body) {
       if (statement.type === 'VariableDeclaration') {
-        identifiers.add((statement.declarations[0].id as es.Identifier).name)
+        const {
+          id: { name }
+        } = getSourceVariableDeclaration(statement)
+        identifiers.add(name)
       } else if (statement.type === 'FunctionDeclaration') {
         if (statement.id === null) {
           throw new Error(
@@ -217,13 +222,13 @@ export function checkForUndefinedVariables(
     BlockStatement: processBlock,
     FunctionDeclaration: processFunction,
     ArrowFunctionExpression: processFunction,
-    ForStatement(forStatement: es.ForStatement, ancestors: es.Node[]) {
+    ForStatement(forStatement: es.ForStatement) {
       const init = forStatement.init!
       if (init.type === 'VariableDeclaration') {
-        identifiersIntroducedByNode.set(
-          forStatement,
-          new Set([(init.declarations[0].id as es.Identifier).name])
-        )
+        const {
+          id: { name }
+        } = getSourceVariableDeclaration(init)
+        identifiersIntroducedByNode.set(forStatement, new Set([name]))
       }
     },
     Identifier(identifier: es.Identifier, ancestors: es.Node[]) {