Extract addition of class methods in type checker to fix bug

Author: bryanlohxz

src/types/checker/index.ts

@@ -25,7 +25,7 @@ import { createArrayType } from '../typeFactories/arrayFactory'
 import { ClassImpl } from '../types/classes'
 import { Method } from '../types/methods'
 import { Frame } from './environment'
-import { addClassesToFrame, resolveClassRelationships } from './prechecks'
+import { addClasses, addClassMethods, addClassParents } from './prechecks'
 
 export type Result = {
   currentType: Type | null
@@ -41,10 +41,12 @@ export const OK_RESULT: Result = newResult(null)
 
 export const check = (node: Node, frame: Frame = Frame.globalFrame()): Result => {
   const typeCheckingFrame = frame.newChildFrame()
-  const addClassesResult = addClassesToFrame(node, typeCheckingFrame)
+  const addClassesResult = addClasses(node, typeCheckingFrame)
   if (addClassesResult.errors.length > 0) return addClassesResult
-  const resolveClassesResult = resolveClassRelationships(node, typeCheckingFrame)
-  if (resolveClassesResult.errors.length > 0) return resolveClassesResult
+  const addClassParentsResult = addClassParents(node, typeCheckingFrame)
+  if (addClassParentsResult.errors.length > 0) return addClassParentsResult
+  const addClassMethodsResult = addClassMethods(node, typeCheckingFrame)
+  if (addClassMethodsResult.errors.length > 0) return addClassMethodsResult
   return typeCheckBody(node, typeCheckingFrame)
 }
 

src/types/checker/prechecks.ts

@@ -1,19 +1,40 @@
 import { Class, ClassImpl, ObjectClass } from '../types/classes'
 import { ConstructorDeclaration, MethodDeclaration } from '../ast/types/classes'
-import { createClass } from '../typeFactories/classFactory'
+import { createClassFieldsAndMethods } from '../typeFactories/classFactory'
 import { createMethodSignature } from '../typeFactories/methodFactory'
 import { CyclicInheritanceError } from '../errors'
 import { MethodSignature } from '../types/methods'
 import { Node } from '../ast/types'
 import { Frame } from './environment'
 import { newResult, OK_RESULT, Result } from '.'
 
-export const addClassesToFrame = (node: Node, frame: Frame): Result => {
+export const addClasses = (node: Node, frame: Frame): Result => {
   switch (node.kind) {
     case 'CompilationUnit': {
       const errors: Error[] = []
       for (const classDeclaration of node.topLevelClassOrInterfaceDeclarations) {
-        const result = addClassesToFrame(classDeclaration, frame)
+        const result = addClasses(classDeclaration, frame)
+        if (result.errors.length > 0) errors.push(...result.errors)
+      }
+      if (errors.length > 0) return newResult(null, errors)
+      return OK_RESULT
+    }
+    case 'NormalClassDeclaration': {
+      const classType = new ClassImpl(node.typeIdentifier)
+      frame.setType(node.typeIdentifier, classType)
+      return newResult(classType)
+    }
+    default:
+      return OK_RESULT
+  }
+}
+
+export const addClassMethods = (node: Node, frame: Frame): Result => {
+  switch (node.kind) {
+    case 'CompilationUnit': {
+      const errors: Error[] = []
+      for (const classDeclaration of node.topLevelClassOrInterfaceDeclarations) {
+        const result = addClassMethods(classDeclaration, frame)
         if (result.errors.length > 0) errors.push(...result.errors)
       }
       if (errors.length > 0) return newResult(null, errors)
@@ -27,12 +48,12 @@ export const addClassesToFrame = (node: Node, frame: Frame): Result => {
     }
     case 'NormalClassDeclaration': {
       const createMethod = (node: ConstructorDeclaration | MethodDeclaration) => {
-        const result = addClassesToFrame(node, frame)
+        const result = addClassMethods(node, frame)
         if (result.errors.length > 0) return result.errors[0]
         return result.currentType as MethodSignature
       }
 
-      const classType = createClass(node, frame, createMethod, createMethod)
+      const classType = createClassFieldsAndMethods(node, frame, createMethod, createMethod)
       if (classType instanceof Error) return newResult(null, [classType])
       return newResult(classType)
     }
@@ -41,12 +62,12 @@ export const addClassesToFrame = (node: Node, frame: Frame): Result => {
   }
 }
 
-export const resolveClassRelationships = (node: Node, frame: Frame): Result => {
+export const addClassParents = (node: Node, frame: Frame): Result => {
   switch (node.kind) {
     case 'CompilationUnit': {
       const errors: Error[] = []
       for (const classDeclaration of node.topLevelClassOrInterfaceDeclarations) {
-        const result = resolveClassRelationships(classDeclaration, frame)
+        const result = addClassParents(classDeclaration, frame)
         if (result.errors.length > 0) errors.push(...result.errors)
       }
       if (errors.length > 0) return newResult(null, errors)

src/types/typeFactories/classFactory.ts

@@ -10,14 +10,15 @@ import { Method, MethodSignature } from '../types/methods'
 type CreateMethod = (node: MethodDeclaration) => MethodSignature | Error
 type CreateConstructor = (node: ConstructorDeclaration) => MethodSignature | Error
 
-export const createClass = (
+export const createClassFieldsAndMethods = (
   node: NormalClassDeclaration,
   frame: Frame,
   createConstructor: CreateConstructor,
   createMethod: CreateMethod
 ): Class | Error => {
-  const classType = new ClassImpl(node.typeIdentifier)
-  frame.setType(node.typeIdentifier, classType)
+  const classType = frame.getType(node.typeIdentifier)
+  if (classType instanceof Error) throw new Error('expected class type to be retrieved')
+  if (!(classType instanceof ClassImpl)) throw new Error('expected class type to be retrieved')
 
   for (const bodyNode of node.classBody) {
     switch (bodyNode.kind) {