Add new source file typechecker.h/typechecker.c, also add typechecker pass to compiler.c, modify CMakesList.txt.

Author: HallofFamer

CMakeLists.txt

@@ -123,6 +123,8 @@ set(Source_Files__compiler
     "src/compiler/token.h"
     "src/compiler/type.c"
     "src/compiler/type.h"
+    "src/compiler/typechecker.c"
+    "src/compiler/typechecker.h"
 )
 source_group("Source Files\\compiler" FILES ${Source_Files__compiler})
 

src/compiler/compiler.c

@@ -6,6 +6,7 @@
 #include "compiler.h"
 #include "parser.h"
 #include "resolver.h"
+#include "typechecker.h"
 #include "../vm/debug.h"
 
 typedef enum {
@@ -1367,6 +1368,11 @@ ObjFunction* compile(VM* vm, const char* source) {
     resolve(&resolver, ast);
     if (resolver.hadError) return NULL;
 
+    TypeChecker typeChecker;
+    initTypeChecker(vm, &typeChecker, vm->config.debugTypetab);
+    typeCheck(&typeChecker, ast);
+    if (typeChecker.hadError) return NULL;
+
     Compiler compiler;
     initCompiler(vm, &compiler, NULL, COMPILE_TYPE_SCRIPT, NULL, false, vm->config.debugCode);
     compileAst(&compiler, ast);

src/compiler/type.c

@@ -153,12 +153,11 @@ static void typeTableAdjustCapacity(TypeTable* typetab, int capacity) {
         entries[i].key = NULL;
         entries[i].value = NULL;
     }
-
     typetab->count = 0;
+
     for (int i = 0; i < typetab->capacity; i++) {
         TypeEntry* entry = &typetab->entries[i];
         if (entry->key == NULL) continue;
-
         TypeEntry* dest = findTypeEntry(entries, capacity, entry->key);
         dest->key = entry->key;
         dest->value = entry->value;

src/compiler/type.h

@@ -72,6 +72,7 @@ static inline CallableTypeModifier callableTypeInitModifier() {
     CallableTypeModifier modifier = {
         .isAsync = false,
         .isClassMethod = false,
+        .isGenerator = false,
         .isInitializer = false,
         .isInstanceMethod = false,
         .isLambda = false,

src/compiler/typechecker.c

@@ -0,0 +1,118 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "typechecker.h"
+#include "../vm/vm.h"
+
+struct ClassTypeChecker {
+    ClassTypeChecker* enclosing;
+    Token name;
+    BehaviorTypeInfo* type;
+    bool isAnonymous;
+};
+
+struct FunctionTypeChecker {
+    FunctionTypeChecker* enclosing;
+    Token name;
+    SymbolTable* symtab;
+    CallableTypeInfo* type;
+    bool isAsync;
+};
+
+static void typeError(TypeChecker* typeChecker, const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    fprintf(stderr, "[line %d] Type Error: ", typeChecker->currentToken.line);
+    vfprintf(stderr, format, args);
+    va_end(args);
+    fputs("\n", stderr);
+    typeChecker->hadError = true;
+}
+
+static void initClassTypeChecker(TypeChecker* typeChecker, ClassTypeChecker* klass, Token name, BehaviorTypeInfo* type, bool isAnonymous) {
+    klass->enclosing = typeChecker->currentClass;
+    klass->name = name;
+    klass->type = type;
+    klass->isAnonymous = isAnonymous;
+    typeChecker->currentClass = klass;
+}
+
+static void endClassTypeChecker(TypeChecker* typeChecker) {
+    typeChecker->currentClass = typeChecker->currentClass->enclosing;
+}
+
+static void initFunctionTypeChecker(TypeChecker* typeChecker, FunctionTypeChecker* function, Token name, CallableTypeInfo* type, bool isAsync) {
+    function->enclosing = typeChecker->currentFunction;
+    function->name = name;
+    function->type = type;
+    function->isAsync = isAsync;
+    typeChecker->currentFunction = function;
+}
+
+static void endFunctionTypeChecker(TypeChecker* typeChecker) {
+    typeChecker->currentFunction = typeChecker->currentFunction->enclosing;
+}
+
+void initTypeChecker(VM* vm, TypeChecker* typeChecker, bool debugTypetab) {
+    typeChecker->vm = vm;
+    typeChecker->currentNamespace = emptyString(vm);
+    typeChecker->currentClass = NULL;
+    typeChecker->currentFunction = NULL;
+    typeChecker->scopeDepth = 0;
+    typeChecker->debugTypetab = debugTypetab;
+    typeChecker->hadError = false;
+}
+
+static void typeCheckExpression(TypeChecker* typeChecker, Ast* ast) {
+    // To be implemented.
+}
+
+static void typeCheckStatement(TypeChecker* typeChecker, Ast* ast) {
+    // To be implemented.
+}
+
+static void typeCheckDeclaration(TypeChecker* typeChecker, Ast* ast) {
+    // To be implemented.
+}
+
+void typeCheckAst(TypeChecker* typeChecker, Ast* ast) {
+    for (int i = 0; i < ast->children->count; i++) {
+        typeCheckChild(typeChecker, ast, i);
+    }
+}
+
+void typeCheckChild(TypeChecker* typeChecker, Ast* ast, int index) {
+    Ast* child = astGetChild(ast, index);
+    child->symtab = ast->symtab;
+    typeChecker->currentToken = child->token;
+
+    switch (child->category) {
+        case AST_CATEGORY_SCRIPT:
+        case AST_CATEGORY_OTHER:
+            typeCheckAst(typeChecker, child);
+            break;
+        case AST_CATEGORY_EXPR:
+            typeCheckExpression(typeChecker, child);
+            break;
+        case AST_CATEGORY_STMT:
+            typeCheckStatement(typeChecker, child);
+            break;
+        case AST_CATEGORY_DECL:
+            typeCheckDeclaration(typeChecker, child);
+            break;
+        default:
+            typeError(typeChecker, "Invalid AST category.");
+    }
+}
+
+void typeCheck(TypeChecker* typeChecker, Ast* ast) {
+    FunctionTypeChecker functionTypeChecker;
+    initFunctionTypeChecker(typeChecker, &functionTypeChecker, syntheticToken("script"), NULL, ast->modifier.isAsync);
+    typeCheckAst(typeChecker, ast);
+
+    endFunctionTypeChecker(typeChecker);
+    if (typeChecker->debugTypetab) {
+        typeTableOutput(typeChecker->vm->typetab);
+    }
+}

src/compiler/typechecker.h

@@ -0,0 +1,26 @@
+#pragma once
+#ifndef clox_typechecker_h
+#define clox_typechecker_h
+
+#include "ast.h"
+
+typedef struct ClassTypeChecker ClassTypeChecker;
+typedef struct FunctionTypeChecker FunctionTypeChecker;
+
+typedef struct {
+    VM* vm;
+    Token currentToken;
+    ObjString* currentNamespace;
+    ClassTypeChecker* currentClass;
+    FunctionTypeChecker* currentFunction;
+    int scopeDepth;
+    bool debugTypetab;
+    bool hadError;
+} TypeChecker;
+
+void initTypeChecker(VM* vm, TypeChecker* typeChecker, bool debugTypetab);
+void typeCheckAst(TypeChecker* typeChecker, Ast* ast);
+void typeCheckChild(TypeChecker* typeChecker, Ast* ast, int index);
+void typeCheck(TypeChecker* typeChecker, Ast* ast);
+
+#endif // !clox_typechecker_h