Modify LoxLexer/LoxParser.g4 grammer, extends parser to handle return type declaration, minor update to native.c and resolver.c, add new test file type.lox.

Author: HallofFamer

grammar/LoxLexer.g4

@@ -1,7 +1,7 @@
 lexer grammar Lox;
 
 SEPARATOR: [ \t\r\n];
-KEYWORD: AND | AS | ASYNC | AWAIT | BREAK | CATCH | CLASS | CONTINUE | DEFAULT | ELSE | FINALLY | FOR | FUN | IF | OR | RETURN | SUPER | THROW| TRAIT | TRY | VAL | VAR | WHILE | WITH | YIELD;
+KEYWORD: AND | AS | ASYNC | AWAIT | BREAK | CATCH | CLASS | CONTINUE | DEFAULT | ELSE | EXTENDS | FINALLY | FOR | FUN | IF | OR | RETURN | SUPER | THROW| TRAIT | TRY | VAL | VAR | WHILE | WITH | YIELD;
 AND: 'and';
 AS: 'as';
 ASYNC: 'async';
@@ -13,6 +13,7 @@ CLASS: 'class';
 CONTINUE: 'continue';
 DEFAULT: 'default';
 ELSE: 'else';
+EXTENDS: 'extends';
 FINALLY: 'finally';
 FOR: 'for';
 FUN: 'fun';

grammar/LoxParser.g4

@@ -40,8 +40,8 @@ call: primary (LPAREN arguments? RPAREN | LSQUARE expression QUESTION? RSQUARE |
 primary: 'nil' | 'true' | 'false' | INT | FLOAT | STRING | IDENTIFIER | (LPAREN expression RPAREN) | (LSQUARE arguments? RSQUARE) | (expression DOTDOT expression) | (CLASS classBody) | (FUN functionBody) | (SUPER DOT IDENTIFIER) | (TRAIT traitBody);
 
 classBody: (LT IDENTIFIER)? (WITH parameters)? LBRACE function* RBRACE;
-function: ASYNC? CLASS? IDENTIFIER functionBody;
+function: ASYNC? CLASS? IDENTIFIER? IDENTIFIER functionBody;
 functionBody: LPAREN parameters? RPAREN block;
 traitBody: (WITH parameters)? LBRACE CLASS? function* RBRACE;
-parameters: (VAR? IDENTIFIER (VAR? COMMA IDENTIFIER)*) | (DOTDOT IDENTIFIER);
+parameters: (VAR? IDENTIFIER? IDENTIFIER (VAR? COMMA IDENTIFIER IDENTIFIER)*) | (DOTDOT IDENTIFIER IDENTIFIER);
 arguments: expression (COMMA expression)*;

src/compiler/parser.c

@@ -1094,11 +1094,19 @@ static Ast* classDeclaration(Parser* parser) {
     return newAst(AST_DECL_CLASS, name, 1, _class);
 }
 
-static Ast* funDeclaration(Parser* parser, bool isAsync) {
+static Ast* funDeclaration(Parser* parser, bool isAsync, bool hasReturnType) {
+    Ast* returnType = NULL;
+    if (hasReturnType) {
+        advance(parser);
+        returnType = variable(parser, parser->previous, false);
+    }
     consume(parser, TOKEN_IDENTIFIER, "Expect function name.");
     Token name = parser->previous;
     Ast* body = function(parser, isAsync, false);
-    return newAst(AST_DECL_FUN, name, 1, body);
+
+    Ast* ast = newAst(AST_DECL_FUN, name, 1, body);
+    if (returnType != NULL) astAppendChild(ast, returnType);
+    return ast;
 }
 
 static Ast* namespaceDeclaration(Parser* parser) {
@@ -1146,15 +1154,22 @@ static Ast* declaration(Parser* parser) {
     if (check(parser, TOKEN_ASYNC) && checkNext(parser, TOKEN_FUN)) {
         advance(parser);
         advance(parser);
-        return funDeclaration(parser, true);
+        return funDeclaration(parser, true, false);
+    }
+    if (check(parser, TOKEN_ASYNC) && checkNext(parser, TOKEN_IDENTIFIER)) {
+        advance(parser);
+        return funDeclaration(parser, true, true);
     }
     else if (check(parser, TOKEN_CLASS) && checkNext(parser, TOKEN_IDENTIFIER)) {
         advance(parser);
         return classDeclaration(parser);
     }
-    else if (check(parser, TOKEN_FUN) && checkNext(parser, TOKEN_IDENTIFIER)) {
+    else if ((check(parser, TOKEN_FUN) && checkNext(parser, TOKEN_IDENTIFIER))) {
         advance(parser);
-        return funDeclaration(parser, false);
+        return funDeclaration(parser, false, false);
+    }
+    else if ((check(parser, TOKEN_IDENTIFIER) && checkNext(parser, TOKEN_IDENTIFIER))) {
+        return funDeclaration(parser, false, true);
     }
     else if (match(parser, TOKEN_NAMESPACE)) {
         return namespaceDeclaration(parser);

src/compiler/resolver.c

@@ -171,6 +171,23 @@ static ObjString* getSymbolFullName(Resolver* resolver, Token token) {
     return takeString(resolver->vm, fullName, length);
 }
 
+static TypeInfo* getTypeForSymbol(Resolver* resolver, Token token) {
+    ObjString* shortName = copyString(resolver->vm, token.start, token.length);
+    TypeInfo* type = typeTableGet(resolver->vm->typetab, shortName);
+    ObjString* fullName = NULL;
+
+    if (type == NULL) {
+        fullName = concatenateString(resolver->vm, resolver->currentNamespace, shortName, ".");
+        type = typeTableGet(resolver->vm->typetab, fullName);
+
+        if (type == NULL) {
+            fullName = concatenateString(resolver->vm, resolver->vm->langNamespace->fullName, shortName, ".");
+            type = typeTableGet(resolver->vm->typetab, fullName);
+        }
+    }
+    return type;
+}
+
 static bool findSymbol(Resolver* resolver, Token token) {
     ObjString* symbol = createSymbol(resolver, token);
     SymbolItem* item = symbolTableGet(resolver->currentSymtab, symbol);
@@ -246,10 +263,6 @@ static bool isTopLevel(Resolver* resolver) {
     return (resolver->currentFunction->enclosing == NULL);
 }
 
-static bool isFunctionScope(SymbolScope scope) {
-    return (scope == SYMBOL_SCOPE_FUNCTION || scope == SYMBOL_SCOPE_METHOD);
-}
-
 static SymbolScope getFunctionScope(Ast* ast) {
     return (ast->kind == AST_DECL_METHOD) ? SYMBOL_SCOPE_METHOD : SYMBOL_SCOPE_FUNCTION;
 }
@@ -471,6 +484,16 @@ static void deriveAstTypeFromBinary(Resolver* resolver, Ast* ast, SymbolItem* it
     }
 }
 
+static void deriveAstTypeForParam(Resolver* resolver, Ast* ast) {
+    Ast* child = astGetChild(ast, 0);
+    resolveChild(resolver, ast, 0);
+    if (child->modifier.isQualified) {
+        ObjString* typeName = createQualifiedSymbol(resolver, child);
+        ast->type = typeTableGet(resolver->vm->typetab, typeName);
+    }
+    else ast->type = getTypeForSymbol(resolver, child->token);
+}
+
 static SymbolItem* getVariable(Resolver* resolver, Ast* ast) {
     ObjString* symbol = createSymbol(resolver, ast->token);
     SymbolItem* item = findLocal(resolver, ast);
@@ -702,6 +725,10 @@ static void resolveOr(Resolver* resolver, Ast* ast) {
 static void resolveParam(Resolver* resolver, Ast* ast) {
     SymbolItem* item = declareVariable(resolver, ast, ast->modifier.isMutable);
     item->state = SYMBOL_STATE_DEFINED;
+    if (astNumChild(ast) > 0) {
+        deriveAstTypeForParam(resolver, ast);
+        item->type = ast->type;
+    }
 }
 
 static void resolvePropertyGet(Resolver* resolver, Ast* ast) {

src/vm/native.c

@@ -208,31 +208,20 @@ ObjClass* getNativeClass(VM* vm, const char* fullName) {
     return AS_CLASS(klass);
 }
 
-static ObjString* getNativeFullName(VM* vm, ObjString* namespaceName, ObjString* shortName) {
-    size_t totalLength = (size_t)namespaceName->length + (size_t)shortName->length + 1;
-    char* chars = bufferNewCString(totalLength);
-    memcpy(chars, namespaceName->chars, namespaceName->length);
-    chars[vm->langNamespace->fullName->length] = '.';
-    memcpy(chars + namespaceName->length + 1, shortName->chars, shortName->length);
-    chars[totalLength] = '\0';
-    return takeString(vm, chars, (int)totalLength);
-}
-
 TypeInfo* getNativeType(VM* vm, const char* name) {
     if (name == NULL) return NULL;
     ObjString* shortName = newString(vm, name);
     ObjString* fullName = NULL;
     TypeInfo* type = typeTableGet(vm->typetab, shortName);
 
     if (type == NULL) {
-        fullName = getNativeFullName(vm, vm->currentNamespace->fullName, shortName);
+        fullName = concatenateString(vm, vm->currentNamespace->fullName, shortName, ".");
         type = typeTableGet(vm->typetab, fullName);
 
         if (type == NULL) {
-            fullName = getNativeFullName(vm, vm->langNamespace->fullName, shortName);
+            fullName = concatenateString(vm, vm->langNamespace->fullName, shortName, ".");
             type = typeTableGet(vm->typetab, fullName);
 
-
             if (type == NULL) {
                 runtimeError(vm, "Type %s is undefined.", name);
                 exit(70);

test/features/type.lox

@@ -0,0 +1,7 @@
+namespace test.features;
+
+Number sum(Number a, Int b) { 
+    return a + b;
+}
+
+println(3.5 + 5);