Modify parser.c to parse void keyword properly, minor update to resolver.c, type.h/type.c and README.md.

Author: HallofFamer

README.md

@@ -43,6 +43,7 @@ https://github.com/munificent/craftinginterpreters
 - Promise API with event loop provided by libuv library for non-blocking IO operations.
 - Introduction of `async` and `await` keywords, which allows C#/JS style of concurrency.
 - Optional static typing support for function/method parameters and return values, types only exist at compile time and are erased at runtime. 
+- Semicolon inference as well as basic type inference for immutable local/global variables. 
 - Customized Runtime configuration for CLox using clox.ini.
 - Allow loading lox source files in lox script and another lox source file with `require` keyword.
 - Cross-platform build with Cmake and package manager with vcpkg.

src/compiler/parser.c

@@ -277,7 +277,7 @@ static void synchronize(Parser* parser) {
 static Ast* expression(Parser* parser);
 static Ast* statement(Parser* parser);
 static Ast* block(Parser* parser);
-static Ast* function(Parser* parser, bool isAsync, bool isLambda);
+static Ast* function(Parser* parser, bool isAsync, bool isLambda, bool isVoid);
 static Ast* declaration(Parser* parser);
 static ParseRule* getRule(TokenSymbol type);
 static Ast* parsePrecedence(Parser* parser, Precedence precedence);
@@ -517,11 +517,11 @@ static Ast* collection(Parser* parser, Token token, bool canAssign) {
 }
 
 static Ast* closure(Parser* parser, Token token, bool canAssign) {
-    return function(parser, false, false);
+    return function(parser, false, false, false);
 }
 
 static Ast* lambda(Parser* parser, Token token, bool canAssign) {
-    return function(parser, false, true);
+    return function(parser, false, true, false);
 }
 
 static Ast* variable(Parser* parser, Token token, bool canAssign) {
@@ -588,13 +588,14 @@ static Ast* lambdaParameters(Parser* parser) {
     return params;
 }
 
-static Ast* function(Parser* parser, bool isAsync, bool isLambda) {
+static Ast* function(Parser* parser, bool isAsync, bool isLambda, bool isVoid) {
     Token token = parser->previous;
     Ast* params = isLambda ? lambdaParameters(parser) : functionParameters(parser);
     Ast* body = block(parser);
     Ast* func = newAst(AST_EXPR_FUNCTION, token, 2, params, body);
     func->modifier.isAsync = isAsync;
     func->modifier.isLambda = isLambda;
+    func->modifier.isVoid = isVoid;
     return func;
 }
 
@@ -603,10 +604,11 @@ static Ast* methods(Parser* parser, Token* name) {
     Ast* methodList = emptyAst(AST_LIST_METHOD, *name);
 
     while (!check(parser, TOKEN_RIGHT_BRACE) && !check(parser, TOKEN_EOF)) {
-        bool isAsync = false, isClass = false, isInitializer = false, hasReturnType = false;
+        bool isAsync = false, isClass = false, isInitializer = false, isVoid = false, hasReturnType = false;
         Ast* returnType = NULL;
         if (match(parser, TOKEN_ASYNC)) isAsync = true;
         if (match(parser, TOKEN_CLASS)) isClass = true;
+        if (match(parser, TOKEN_VOID)) isVoid = true;
         if (check2(parser, TOKEN_IDENTIFIER) || (check(parser, TOKEN_IDENTIFIER) && tokenIsOperator(parser->next))) {
             hasReturnType = true;
             returnType = type_(parser, "Expect method return type.");
@@ -623,6 +625,7 @@ static Ast* methods(Parser* parser, Token* name) {
         method->modifier.isAsync = isAsync;
         method->modifier.isClass = isClass;
         method->modifier.isInitializer = isInitializer;
+        method->modifier.isVoid = isVoid;
 
         if (hasReturnType) {
             astAppendChild(method, returnType);
@@ -711,10 +714,10 @@ static Ast* yield(Parser* parser, Token token, bool canAssign) {
 
 static Ast* async(Parser* parser, Token token, bool canAssign) { 
     if (match(parser, TOKEN_FUN)) {
-        return function(parser, true, false);
+        return function(parser, true, false, false);
     }
     else if (match(parser, TOKEN_LEFT_BRACE)) {
-        return function(parser, true, true);
+        return function(parser, true, true, false);
     }
     else {
         parseErrorAtPrevious(parser, "Can only use async as expression modifier for anonymous functions or lambda.");
@@ -1115,12 +1118,14 @@ static Ast* classDeclaration(Parser* parser) {
 }
 
 static Ast* funDeclaration(Parser* parser, bool isAsync, bool hasReturnType) {
+    bool isVoid = match(parser, TOKEN_VOID);
     Ast* returnType = hasReturnType ? type_(parser, "Expect function return type.") : NULL;
     consume(parser, TOKEN_IDENTIFIER, "Expect function name.");
     Token name = parser->previous;
-    Ast* body = function(parser, isAsync, false);
+    Ast* body = function(parser, isAsync, false, isVoid);
 
     Ast* ast = newAst(AST_DECL_FUN, name, 1, body);
+    ast->modifier.isVoid = true;
     if (returnType != NULL) astAppendChild(ast, returnType);
     return ast;
 }
@@ -1172,7 +1177,11 @@ static Ast* declaration(Parser* parser) {
         advance(parser);
         return funDeclaration(parser, true, false);
     }
-    if (check(parser, TOKEN_ASYNC) && checkNext(parser, TOKEN_IDENTIFIER)) {
+    else if (check(parser, TOKEN_ASYNC) && checkNext(parser, TOKEN_VOID)) {
+        advance(parser);
+        return funDeclaration(parser, true, false);
+    }
+    else if (check(parser, TOKEN_ASYNC) && checkNext(parser, TOKEN_IDENTIFIER)) {
         advance(parser);
         return funDeclaration(parser, true, true);
     }
@@ -1184,6 +1193,9 @@ static Ast* declaration(Parser* parser) {
         advance(parser);
         return funDeclaration(parser, false, false);
     }
+    else if (check(parser, TOKEN_VOID) && checkNext(parser, TOKEN_IDENTIFIER)) {
+        return funDeclaration(parser, false, false);
+    }
     else if (check2(parser, TOKEN_IDENTIFIER)) {
         return funDeclaration(parser, false, true);
     }

src/compiler/resolver.c

@@ -174,6 +174,7 @@ static void setFunctionTypeModifier(Ast* ast, CallableTypeInfo* callableType) {
     callableType->modifier.isInstanceMethod = !ast->modifier.isClass;
     callableType->modifier.isLambda = ast->modifier.isLambda;
     callableType->modifier.isVariadic = ast->modifier.isVariadic;
+    callableType->modifier.isVoid = ast->modifier.isVoid;
 }
 
 static bool findSymbol(Resolver* resolver, Token token) {
@@ -473,6 +474,7 @@ static void function(Resolver* resolver, Ast* ast, bool isLambda, bool isAsync)
     functionResolver.modifier.isInitializer = ast->modifier.isInitializer;
     functionResolver.modifier.isInstanceMethod = !ast->modifier.isClass;
     functionResolver.modifier.isLambda = isLambda;
+    functionResolver.modifier.isVoid = ast->modifier.isVoid;
 
     SymbolScope scope = getFunctionScope(ast);
     beginScope(resolver, ast, scope);
@@ -943,6 +945,9 @@ static void resolveReturnStatement(Resolver* resolver, Ast* ast) {
         semanticError(resolver, "Cannot use 'return' from an initializer.");
     }
     else if (astHasChild(ast)) {
+        if (resolver->currentFunction->modifier.isVoid) {
+            semanticError(resolver, "Cannot return value from a void function/method.");
+        }
         resolveChild(resolver, ast, 0);
     }
 }

src/compiler/type.c

@@ -254,7 +254,7 @@ static void typeTableOutputMethod(TypeTable* methods) {
             printf("      %s", method->modifier.isAsync ? "async " : "");
 
             if (method->returnType == NULL) printf("dynamic ");
-            else if (memcmp(method->returnType->shortName->chars, "Nil", 3) == 0) printf("void ");
+            else if (method->modifier.isVoid) printf("void ");
             else printf("%s ", method->returnType->shortName->chars);
             printf("%s(", entry->key->chars);
 
@@ -290,7 +290,7 @@ static void typeTableOutputBehavior(BehaviorTypeInfo* behavior) {
 static void typeTableOutputFunction(CallableTypeInfo* function) {
     printf("    signature: ");
     if (function->returnType == NULL) printf("dynamic ");
-    else if (memcmp(function->returnType->shortName->chars, "Nil", 3) == 0) printf("void ");
+    else if (function->modifier.isVoid) printf("void ");
     else printf("%s ", function->returnType->shortName->chars);
     printf("%s(", function->baseType.shortName->chars);
 

src/compiler/type.h

@@ -47,6 +47,7 @@ typedef struct {
     bool isInstanceMethod;
     bool isLambda;
     bool isVariadic;
+    bool isVoid;
 } CallableTypeModifier;
 
 typedef struct {
@@ -76,7 +77,8 @@ static inline CallableTypeModifier callableTypeInitModifier() {
         .isInitializer = false,
         .isInstanceMethod = false,
         .isLambda = false,
-        .isVariadic = false
+        .isVariadic = false,
+        .isVoid = false
     };
     return modifier;
 }