Refactors out identcheck and typeutils code

generators/wraith.lex

@@ -12,7 +12,6 @@
 "double"                    return DOUBLE;
 "string"                    return STRING;
 "bool"                      return BOOL;
-"MemoryAddress"             return MEMORYADDRESS;
 "struct"                    return STRUCT;
 "return"                    return RETURN;
 "static"                    return STATIC;
@@ -41,7 +40,6 @@
 ";"                         return SEMICOLON;
 ":"                         return COLON;
 "?"                         return QUESTION;
-"@"                         return AT;
 "("                         return LEFT_PAREN;
 ")"                         return RIGHT_PAREN;
 "["                         return LEFT_BRACKET;

generators/wraith.y

@@ -25,7 +25,6 @@ extern FILE *yyin;
 %token DOUBLE
 %token STRING
 %token BOOL
-%token MEMORYADDRESS
 %token STRUCT
 %token RETURN
 %token STATIC
@@ -55,7 +54,6 @@ extern FILE *yyin;
 %token SEMICOLON
 %token COLON
 %token QUESTION
-%token AT
 %token LEFT_PAREN
 %token RIGHT_PAREN
 %token LEFT_BRACE
@@ -109,17 +107,9 @@ BaseType                : VOID
                         {
                             $$ = MakePrimitiveTypeNode(Bool);
                         }
-                        | MEMORYADDRESS
-                        {
-                            $$ = MakePrimitiveTypeNode(MemoryAddress);
-                        }
-                        | Identifier GenericArgumentClauseNonEmpty
-                        {
-                            $$ = MakeConcreteGenericTypeNode($1, $2);
-                        }
                         | Identifier
                         {
-                            $$ = MakeCustomTypeNode($1);
+                            $$ = MakeCustomTypeNode(yytext);
                         }
                         | REFERENCE LESS_THAN Type GREATER_THAN
                         {
@@ -151,40 +141,11 @@ AccessExpression        : Identifier POINT AccessExpression
                             $$ = $1;
                         }
 
-SystemCallExpression    : AT Identifier
-                        {
-                            $$ = $2;
-                        }
-
 Number                  : NUMBER
                         {
                             $$ = MakeNumberNode(yytext);
                         }
 
-FieldInit               : Identifier COLON Expression
-                        {
-                            $$ = MakeFieldInitNode($1, $3);
-                        }
-
-StructInitFields        : FieldInit
-                        {
-                            $$ = StartStructInitFieldsNode($1);
-                        }
-                        | StructInitFields COMMA FieldInit
-                        {
-                            $$ = AddFieldInitNode($1, $3);
-                        }
-                        |
-                        {
-                            $$ = MakeEmptyFieldInitNode();
-                        }
-                        ;
-
-StructInitExpression    : Type LEFT_BRACE StructInitFields RIGHT_BRACE
-                        {
-                            $$ = MakeStructInitExpressionNode($1, $3);
-                        }
-
 PrimaryExpression       : Number
                         | STRING_LITERAL
                         {
@@ -196,7 +157,6 @@ PrimaryExpression       : Number
                         }
                         | FunctionCallExpression
                         | AccessExpression
-                        | StructInitExpression
                         ;
 
 UnaryExpression         : BANG Expression
@@ -270,13 +230,9 @@ ReturnStatement         : RETURN Expression
                             $$ = MakeReturnVoidStatementNode();
                         }
 
-FunctionCallExpression  : AccessExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
+FunctionCallExpression  : AccessExpression LEFT_PAREN Arguments RIGHT_PAREN
                         {
-                            $$ = MakeFunctionCallExpressionNode($1, $4, $2);
+                            $$ = MakeFunctionCallExpressionNode($1, $3);
-                        }
-                        | SystemCallExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
-                        {
-                            $$ = MakeSystemCallExpressionNode($1, $4, $2);
                         }
 
 PartialStatement        : FunctionCallExpression
@@ -319,11 +275,11 @@ Statements              : Statement
                             $$ = AddStatement($1, $2);
                         }
 
-Arguments               : Expression
+Arguments               : PrimaryExpression
                         {
                             $$ = StartFunctionArgumentSequenceNode($1);
                         }
-                        | Arguments COMMA Expression
+                        | Arguments COMMA PrimaryExpression
                         {
                             $$ = AddFunctionArgumentNode($1, $3);
                         }
@@ -351,32 +307,9 @@ Body                    : LEFT_BRACE Statements RIGHT_BRACE
                             $$ = $2;
                         }
 
-GenericDeclaration      : Identifier
+GenericArgument         : Identifier
                         {
-                            $$ = MakeGenericDeclarationNode($1, NULL);
+                            $$ = MakeGenericArgumentNode($1, NULL);
-                        }
-
-GenericDeclarations     : GenericDeclaration
-                        {
-                            $$ = StartGenericDeclarationsNode($1);
-                        }
-                        | GenericDeclarations COMMA GenericDeclaration
-                        {
-                            $$ = AddGenericDeclaration($1, $3);
-                        }
-
-GenericDeclarationClause    : LESS_THAN GenericDeclarations GREATER_THAN
-                            {
-                                $$ = $2;
-                            }
-                            |
-                            {
-                                $$ = MakeEmptyGenericDeclarationsNode();
-                            }
-
-GenericArgument         : Type
-                        {
-                            $$ = MakeGenericArgumentNode($1);
                         }
 
 GenericArguments        : GenericArgument
@@ -388,23 +321,21 @@ GenericArguments        : GenericArgument
                             $$ = AddGenericArgument($1, $3);
                         }
 
-GenericArgumentClauseNonEmpty   : LESS_THAN GenericArguments GREATER_THAN
+GenericArgumentsClause  : LESS_THAN GenericArguments GREATER_THAN
                         {
                             $$ = $2;
                         }
-                                ;
-
-GenericArgumentClause   : GenericArgumentClauseNonEmpty
                         |
                         {
                             $$ = MakeEmptyGenericArgumentsNode();
                         }
 
-FunctionSignature       : Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+
+FunctionSignature       : Identifier GenericArgumentsClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
                         {
                             $$ = MakeFunctionSignatureNode($1, $7, $4, MakeFunctionModifiersNode(NULL, 0), $2);
                         }
-                        | STATIC Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
+                        | STATIC Identifier GenericArgumentsClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
                         {
                             Node *modifier = MakeStaticNode();
                             $$ = MakeFunctionSignatureNode($2, $8, $5, MakeFunctionModifiersNode(&modifier, 1), $3);
@@ -415,9 +346,9 @@ FunctionDeclaration     : FunctionSignature Body
                             $$ = MakeFunctionDeclarationNode($1, $2);
                         }
 
-StructDeclaration       : STRUCT Identifier GenericDeclarationClause LEFT_BRACE Declarations RIGHT_BRACE
+StructDeclaration       : STRUCT Identifier LEFT_BRACE Declarations RIGHT_BRACE
                         {
-                            $$ = MakeStructDeclarationNode($2, $5, $3);
+                            $$ = MakeStructDeclarationNode($2, $4);
                         }
 
 Declaration             : FunctionDeclaration

generic.w

@@ -5,55 +5,14 @@ struct Foo {
 
     static Func<T>(t: T): T {
         foo: T = t;
-        return Foo.Func2(foo);
+        return Func2(foo);
-    }
-}
-
-struct MemoryBlock<T>
-{
-	start: MemoryAddress;
-	capacity: uint;
-
-	AddressOf(index: uint): MemoryAddress
-    {
-        return start + (index * @sizeof<T>());
-    }
-
-    Get(index: uint): T
-    {
-        return @dereference<T>(AddressOf(index));
-    }
-
-    Set(index: uint, value: T): void
-    {
-        @memcpy(AddressOf(index), @addr(value), @sizeof<T>());
-    }
-
-    Free(): void
-    {
-        @free(start);
     }
 }
 
 struct Program {
-    static Main(): int {
+    static main(): int {
         x: int = 4;
         y: int = Foo.Func(x);
-        block: MemoryBlock<int> = MemoryBlock<int>
+        return x;
-        {
-            capacity: y,
-            start: @malloc(y * @sizeof<int>())
-        };
-        block.Set(0, 5);
-        block.Set(1, 3);
-        block.Set(2, 9);
-        block.Set(3, 100);
-        Console.PrintLine("%p", block.start);
-        Console.PrintLine("%i", block.Get(0));
-        Console.PrintLine("%i", block.Get(1));
-        Console.PrintLine("%i", block.Get(2));
-        Console.PrintLine("%i", block.Get(3));
-        block.Free();
-        return 0;
     }
 }

src/ast.c

@@ -19,8 +19,6 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "BinaryExpression";
     case Comment:
         return "Comment";
-    case ConcreteGenericTypeNode:
-        return "ConcreteGenericTypeNode";
     case CustomTypeNode:
         return "CustomTypeNode";
     case Declaration:
@@ -29,8 +27,6 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "ForLoop";
     case DeclarationSequence:
         return "DeclarationSequence";
-    case FieldInit:
-        return "FieldInit";
     case FunctionArgumentSequence:
         return "FunctionArgumentSequence";
     case FunctionCallExpression:
@@ -47,10 +43,6 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "GenericArgument";
     case GenericArguments:
         return "GenericArguments";
-    case GenericDeclaration:
-        return "GenericDeclaration";
-    case GenericDeclarations:
-        return "GenericDeclarations";
     case GenericTypeNode:
         return "GenericTypeNode";
     case Identifier:
@@ -75,12 +67,6 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "StringLiteral";
     case StructDeclaration:
         return "StructDeclaration";
-    case StructInit:
-        return "StructInit";
-    case StructInitFields:
-        return "StructInitFields";
-    case SystemCall:
-        return "SystemCall";
     case Type:
         return "Type";
     case UnaryExpression:
@@ -103,12 +89,11 @@ Node *MakePrimitiveTypeNode(PrimitiveType type)
     return node;
 }
 
-Node *MakeCustomTypeNode(Node *identifierNode)
+Node *MakeCustomTypeNode(char *name)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = CustomTypeNode;
-    node->customType.name = strdup(identifierNode->identifier.name);
+    node->customType.name = strdup(name);
-    free(identifierNode);
     return node;
 }
 
@@ -120,18 +105,6 @@ Node *MakeReferenceTypeNode(Node *typeNode)
     return node;
 }
 
-Node *MakeConcreteGenericTypeNode(
-    Node *identifierNode,
-    Node *genericArgumentsNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = ConcreteGenericTypeNode;
-    node->concreteGenericType.name = strdup(identifierNode->identifier.name);
-    node->concreteGenericType.genericArguments = genericArgumentsNode;
-    free(identifierNode);
-    return node;
-}
-
 Node *MakeTypeNode(Node *typeNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
@@ -313,7 +286,7 @@ Node *MakeFunctionSignatureNode(
     node->functionSignature.type = typeNode;
     node->functionSignature.arguments = arguments;
     node->functionSignature.modifiers = modifiersNode;
-    node->functionSignature.genericDeclarations = genericArgumentsNode;
+    node->functionSignature.genericArguments = genericArgumentsNode;
     return node;
 }
 
@@ -330,14 +303,12 @@ Node *MakeFunctionDeclarationNode(
 
 Node *MakeStructDeclarationNode(
     Node *identifierNode,
-    Node *declarationSequenceNode,
+    Node *declarationSequenceNode)
-    Node *genericArgumentsNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = StructDeclaration;
     node->structDeclaration.identifier = identifierNode;
     node->structDeclaration.declarationSequence = declarationSequenceNode;
-    node->structDeclaration.genericDeclarations = genericArgumentsNode;
     return node;
 }
 
@@ -396,55 +367,12 @@ Node *MakeEmptyFunctionArgumentSequenceNode()
     return node;
 }
 
-Node *MakeGenericDeclarationNode(Node *identifierNode, Node *constraintNode)
+Node *MakeGenericArgumentNode(Node *identifierNode, Node *constraintNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = GenericDeclaration;
-    node->genericDeclaration.identifier = identifierNode;
-    node->genericDeclaration.constraint = constraintNode;
-    return node;
-}
-
-Node *StartGenericDeclarationsNode(Node *genericArgumentNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = GenericDeclarations;
-    node->genericDeclarations.declarations = (Node **)malloc(sizeof(Node *));
-    node->genericDeclarations.declarations[0] = genericArgumentNode;
-    node->genericDeclarations.count = 1;
-    return node;
-}
-
-Node *AddGenericDeclaration(
-    Node *genericDeclarationsNode,
-    Node *genericDeclarationNode)
-{
-    genericDeclarationsNode->genericDeclarations.declarations =
-        (Node **)realloc(
-            genericDeclarationsNode->genericDeclarations.declarations,
-            sizeof(Node *) *
-                (genericDeclarationsNode->genericDeclarations.count + 1));
-    genericDeclarationsNode->genericDeclarations
-        .declarations[genericDeclarationsNode->genericDeclarations.count] =
-        genericDeclarationNode;
-    genericDeclarationsNode->genericDeclarations.count += 1;
-    return genericDeclarationsNode;
-}
-
-Node *MakeEmptyGenericDeclarationsNode()
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = GenericDeclarations;
-    node->genericDeclarations.declarations = NULL;
-    node->genericDeclarations.count = 0;
-    return node;
-}
-
-Node *MakeGenericArgumentNode(Node *typeNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = GenericArgument;
-    node->genericArgument.type = typeNode;
+    node->genericArgument.identifier = identifierNode;
+    node->genericArgument.constraint = constraintNode;
     return node;
 }
 
@@ -460,13 +388,13 @@ Node *StartGenericArgumentsNode(Node *genericArgumentNode)
 
 Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode)
 {
-    genericArgumentsNode->genericArguments.arguments = realloc(
+    genericArgumentsNode->genericArguments.arguments = (Node **)realloc(
         genericArgumentsNode->genericArguments.arguments,
         sizeof(Node *) * (genericArgumentsNode->genericArguments.count + 1));
     genericArgumentsNode->genericArguments
         .arguments[genericArgumentsNode->genericArguments.count] =
         genericArgumentNode;
-    genericArgumentNode->genericArguments.count += 1;
+    genericArgumentsNode->genericArguments.count += 1;
     return genericArgumentsNode;
 }
 
@@ -489,27 +417,12 @@ Node *MakeGenericTypeNode(char *name)
 
 Node *MakeFunctionCallExpressionNode(
     Node *identifierNode,
-    Node *argumentSequenceNode,
+    Node *argumentSequenceNode)
-    Node *genericArgumentsNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = FunctionCallExpression;
     node->functionCallExpression.identifier = identifierNode;
     node->functionCallExpression.argumentSequence = argumentSequenceNode;
-    node->functionCallExpression.genericArguments = genericArgumentsNode;
-    return node;
-}
-
-Node *MakeSystemCallExpressionNode(
-    Node *identifierNode,
-    Node *argumentSequenceNode,
-    Node *genericArgumentsNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = SystemCall;
-    node->systemCall.identifier = identifierNode;
-    node->systemCall.argumentSequence = argumentSequenceNode;
-    node->systemCall.genericArguments = genericArgumentsNode;
     return node;
 }
 
@@ -563,55 +476,6 @@ Node *MakeForLoopNode(
     return node;
 }
 
-Node *MakeFieldInitNode(Node *identifierNode, Node *expressionNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = FieldInit;
-    node->fieldInit.identifier = identifierNode;
-    node->fieldInit.expression = expressionNode;
-    return node;
-}
-
-Node *StartStructInitFieldsNode(Node *fieldInitNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = StructInitFields;
-    node->structInitFields.fieldInits = (Node **)malloc(sizeof(Node *));
-    node->structInitFields.fieldInits[0] = fieldInitNode;
-    node->structInitFields.count = 1;
-    return node;
-}
-
-Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode)
-{
-    structInitFieldsNode->structInitFields.fieldInits = realloc(
-        structInitFieldsNode->structInitFields.fieldInits,
-        sizeof(Node *) * (structInitFieldsNode->structInitFields.count + 1));
-    structInitFieldsNode->structInitFields
-        .fieldInits[structInitFieldsNode->structInitFields.count] =
-        fieldInitNode;
-    structInitFieldsNode->structInitFields.count += 1;
-    return structInitFieldsNode;
-}
-
-Node *MakeEmptyFieldInitNode()
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = StructInitFields;
-    node->structInitFields.fieldInits = NULL;
-    node->structInitFields.count = 0;
-    return node;
-}
-
-Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = StructInit;
-    node->structInit.type = typeNode;
-    node->structInit.initFields = structInitFieldsNode;
-    return node;
-}
-
 static const char *PrimitiveTypeToString(PrimitiveType type)
 {
     switch (type)
@@ -622,8 +486,6 @@ static const char *PrimitiveTypeToString(PrimitiveType type)
         return "UInt";
     case Bool:
         return "Bool";
-    case MemoryAddress:
-        return "MemoryAddress";
     case Void:
         return "Void";
     }
@@ -694,11 +556,6 @@ void PrintNode(Node *node, uint32_t tabCount)
         PrintNode(node->binaryExpression.right, tabCount + 1);
         return;
 
-    case ConcreteGenericTypeNode:
-        printf("%s\n", node->concreteGenericType.name);
-        PrintNode(node->concreteGenericType.genericArguments, tabCount + 1);
-        return;
-
     case CustomTypeNode:
         printf("%s\n", node->customType.name);
         return;
@@ -717,12 +574,6 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
-    case FieldInit:
-        printf("\n");
-        PrintNode(node->fieldInit.identifier, tabCount + 1);
-        PrintNode(node->fieldInit.expression, tabCount + 1);
-        return;
-
     case ForLoop:
         printf("\n");
         PrintNode(node->forLoop.declaration, tabCount + 1);
@@ -743,7 +594,6 @@ void PrintNode(Node *node, uint32_t tabCount)
         printf("\n");
         PrintNode(node->functionCallExpression.identifier, tabCount + 1);
         PrintNode(node->functionCallExpression.argumentSequence, tabCount + 1);
-        PrintNode(node->functionCallExpression.genericArguments, tabCount + 1);
         return;
 
     case FunctionDeclaration:
@@ -763,7 +613,7 @@ void PrintNode(Node *node, uint32_t tabCount)
     case FunctionSignature:
         printf("\n");
         PrintNode(node->functionSignature.identifier, tabCount + 1);
-        PrintNode(node->functionSignature.genericDeclarations, tabCount + 1);
+        PrintNode(node->functionSignature.genericArguments, tabCount + 1);
         PrintNode(node->functionSignature.arguments, tabCount + 1);
         PrintNode(node->functionSignature.type, tabCount + 1);
         PrintNode(node->functionSignature.modifiers, tabCount + 1);
@@ -781,7 +631,9 @@ void PrintNode(Node *node, uint32_t tabCount)
 
     case GenericArgument:
         printf("\n");
-        PrintNode(node->genericArgument.type, tabCount + 1);
+        PrintNode(node->genericArgument.identifier, tabCount + 1);
+        /* Constraint nodes are not implemented. */
+        /* PrintNode(node->genericArgument.constraint, tabCount + 1); */
         return;
 
     case GenericArguments:
@@ -792,21 +644,6 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
-    case GenericDeclaration:
-        printf("\n");
-        PrintNode(node->genericDeclaration.identifier, tabCount + 1);
-        /* Constraint nodes are not implemented. */
-        /* PrintNode(node->genericDeclaration.constraint, tabCount + 1); */
-        return;
-
-    case GenericDeclarations:
-        printf("\n");
-        for (i = 0; i < node->genericDeclarations.count; i += 1)
-        {
-            PrintNode(node->genericDeclarations.declarations[i], tabCount + 1);
-        }
-        return;
-
     case GenericTypeNode:
         printf("%s\n", node->genericType.name);
         return;
@@ -878,27 +715,6 @@ void PrintNode(Node *node, uint32_t tabCount)
         PrintNode(node->structDeclaration.declarationSequence, tabCount + 1);
         return;
 
-    case StructInit:
-        printf("\n");
-        PrintNode(node->structInit.type, tabCount + 1);
-        PrintNode(node->structInit.initFields, tabCount + 1);
-        return;
-
-    case StructInitFields:
-        printf("\n");
-        for (i = 0; i < node->structInitFields.count; i += 1)
-        {
-            PrintNode(node->structInitFields.fieldInits[i], tabCount + 1);
-        }
-        return;
-
-    case SystemCall:
-        printf("\n");
-        PrintNode(node->systemCall.identifier, tabCount + 1);
-        PrintNode(node->systemCall.argumentSequence, tabCount + 1);
-        PrintNode(node->systemCall.genericArguments, tabCount + 1);
-        return;
-
     case Type:
         printf("\n");
         PrintNode(node->type.typeNode, tabCount + 1);
@@ -938,10 +754,6 @@ void Recurse(Node *node, void (*func)(Node *))
     case Comment:
         return;
 
-    case ConcreteGenericTypeNode:
-        func(node->concreteGenericType.genericArguments);
-        return;
-
     case CustomTypeNode:
         return;
 
@@ -957,11 +769,6 @@ void Recurse(Node *node, void (*func)(Node *))
         }
         return;
 
-    case FieldInit:
-        func(node->fieldInit.identifier);
-        func(node->fieldInit.expression);
-        return;
-
     case ForLoop:
         func(node->forLoop.declaration);
         func(node->forLoop.startNumber);
@@ -979,7 +786,6 @@ void Recurse(Node *node, void (*func)(Node *))
     case FunctionCallExpression:
         func(node->functionCallExpression.identifier);
         func(node->functionCallExpression.argumentSequence);
-        func(node->functionCallExpression.genericArguments);
         return;
 
     case FunctionDeclaration:
@@ -999,7 +805,7 @@ void Recurse(Node *node, void (*func)(Node *))
         func(node->functionSignature.type);
         func(node->functionSignature.arguments);
         func(node->functionSignature.modifiers);
-        func(node->functionSignature.genericDeclarations);
+        func(node->functionSignature.genericArguments);
         return;
 
     case FunctionSignatureArguments:
@@ -1010,8 +816,9 @@ void Recurse(Node *node, void (*func)(Node *))
         return;
 
     case GenericArgument:
-        func(node->genericArgument.type);
+        func(node->genericArgument.identifier);
-        break;
+        func(node->genericArgument.constraint);
+        return;
 
     case GenericArguments:
         for (i = 0; i < node->genericArguments.count; i += 1)
@@ -1020,18 +827,6 @@ void Recurse(Node *node, void (*func)(Node *))
         }
         return;
 
-    case GenericDeclaration:
-        func(node->genericDeclaration.identifier);
-        func(node->genericDeclaration.constraint);
-        return;
-
-    case GenericDeclarations:
-        for (i = 0; i < node->genericDeclarations.count; i += 1)
-        {
-            func(node->genericDeclarations.declarations[i]);
-        }
-        return;
-
     case GenericTypeNode:
         return;
 
@@ -1083,26 +878,7 @@ void Recurse(Node *node, void (*func)(Node *))
         func(node->structDeclaration.declarationSequence);
         return;
 
-    case StructInit:
-        func(node->structInit.type);
-        func(node->structInit.initFields);
-        return;
-
-    case StructInitFields:
-        for (i = 0; i < node->structInitFields.count; i += 1)
-        {
-            func(node->structInitFields.fieldInits[i]);
-        }
-        return;
-
-    case SystemCall:
-        func(node->systemCall.identifier);
-        func(node->systemCall.argumentSequence);
-        func(node->systemCall.genericArguments);
-        return;
-
     case Type:
-        func(node->type.typeNode);
         return;
 
     case UnaryExpression:
@@ -1120,8 +896,6 @@ void Recurse(Node *node, void (*func)(Node *))
 
 TypeTag *MakeTypeTag(Node *node)
 {
-    uint32_t i;
-
     if (node == NULL)
     {
         fprintf(
@@ -1152,28 +926,6 @@ TypeTag *MakeTypeTag(Node *node)
         tag->value.customType = strdup(node->customType.name);
         break;
 
-    case ConcreteGenericTypeNode:
-        tag->type = ConcreteGeneric;
-        tag->value.concreteGenericType.name =
-            strdup(node->concreteGenericType.name);
-        tag->value.concreteGenericType.genericArgumentCount =
-            node->concreteGenericType.genericArguments->genericArguments.count;
-        tag->value.concreteGenericType.genericArguments = malloc(
-            sizeof(TypeTag *) *
-            tag->value.concreteGenericType.genericArgumentCount);
-
-        for (i = 0;
-             i <
-             node->concreteGenericType.genericArguments->genericArguments.count;
-             i += 1)
-        {
-            tag->value.concreteGenericType.genericArguments[i] = MakeTypeTag(
-                node->concreteGenericType.genericArguments->genericArguments
-                    .arguments[i]
-                    ->genericArgument.type);
-        }
-        break;
-
     case Declaration:
         tag = MakeTypeTag(node->declaration.type);
         break;
@@ -1193,10 +945,10 @@ TypeTag *MakeTypeTag(Node *node)
         tag = MakeTypeTag(node->allocExpression.type);
         break;
 
-    case GenericDeclaration:
+    case GenericArgument:
         tag->type = Generic;
         tag->value.genericType =
-            strdup(node->genericDeclaration.identifier->identifier.name);
+            strdup(node->genericArgument.identifier->identifier.name);
         break;
 
     case GenericTypeNode:
@@ -1218,8 +970,6 @@ TypeTag *MakeTypeTag(Node *node)
 
 char *TypeTagToString(TypeTag *tag)
 {
-    uint32_t i;
-
     if (tag == NULL)
     {
         fprintf(
@@ -1238,82 +988,24 @@ char *TypeTagToString(TypeTag *tag)
     {
         char *inner = TypeTagToString(tag->value.referenceType);
         size_t innerStrLen = strlen(inner);
-        char *result = malloc(sizeof(char) * (innerStrLen + 6));
+        char *result = malloc(sizeof(char) * (innerStrLen + 5));
         sprintf(result, "Ref<%s>", inner);
         return result;
     }
     case Custom:
     {
         char *result =
-            malloc(sizeof(char) * (strlen(tag->value.customType) + 9));
+            malloc(sizeof(char) * (strlen(tag->value.customType) + 8));
         sprintf(result, "Custom<%s>", tag->value.customType);
         return result;
     }
     case Generic:
     {
         char *result =
-            malloc(sizeof(char) * (strlen(tag->value.genericType) + 10));
+            malloc(sizeof(char) * (strlen(tag->value.customType) + 9));
-        sprintf(result, "Generic<%s>", tag->value.genericType);
+        sprintf(result, "Generic<%s>", tag->value.customType);
         return result;
     }
-
-    case ConcreteGeneric:
-    {
-        char *result = strdup(tag->value.concreteGenericType.name);
-        uint32_t len = strlen(result);
-        len += 2;
-        result = realloc(result, sizeof(char) * len);
-        strcat(result, "<");
-
-        for (i = 0; i < tag->value.concreteGenericType.genericArgumentCount;
-             i += 1)
-        {
-            char *inner = TypeTagToString(
-                tag->value.concreteGenericType.genericArguments[i]);
-            len += strlen(inner);
-            result = realloc(result, sizeof(char) * (len + 3));
-            if (i != tag->value.concreteGenericType.genericArgumentCount - 1)
-            {
-                strcat(result, ", ");
-            }
-            strcat(result, inner);
-        }
-        result = realloc(result, sizeof(char) * (len + 1));
-        strcat(result, ">");
-        return result;
-    }
-    }
-}
-
-uint8_t TypeTagEqual(TypeTag *typeTagA, TypeTag *typeTagB)
-{
-    if (typeTagA->type != typeTagB->type)
-    {
-        return 0;
-    }
-
-    switch (typeTagA->type)
-    {
-    case Primitive:
-        return typeTagA->value.primitiveType == typeTagB->value.primitiveType;
-
-    case Reference:
-        return TypeTagEqual(
-            typeTagA->value.referenceType,
-            typeTagB->value.referenceType);
-
-    case Custom:
-        return strcmp(typeTagA->value.customType, typeTagB->value.customType) ==
-               0;
-
-    case Generic:
-        return strcmp(
-                   typeTagA->value.genericType,
-                   typeTagB->value.genericType) == 0;
-
-    default:
-        fprintf(stderr, "Invalid type comparison!");
-        return 0;
     }
 }
 
@@ -1364,11 +1056,6 @@ void LinkParentPointers(Node *node, Node *prev)
         }
         return;
 
-    case FieldInit:
-        LinkParentPointers(node->fieldInit.identifier, node);
-        LinkParentPointers(node->fieldInit.expression, node);
-        return;
-
     case ForLoop:
         LinkParentPointers(node->forLoop.declaration, node);
         LinkParentPointers(node->forLoop.startNumber, node);
@@ -1407,7 +1094,7 @@ void LinkParentPointers(Node *node, Node *prev)
         LinkParentPointers(node->functionSignature.type, node);
         LinkParentPointers(node->functionSignature.arguments, node);
         LinkParentPointers(node->functionSignature.modifiers, node);
-        LinkParentPointers(node->functionSignature.genericDeclarations, node);
+        LinkParentPointers(node->functionSignature.genericArguments, node);
         return;
 
     case FunctionSignatureArguments:
@@ -1420,7 +1107,8 @@ void LinkParentPointers(Node *node, Node *prev)
         return;
 
     case GenericArgument:
-        LinkParentPointers(node->genericArgument.type, node);
+        LinkParentPointers(node->genericArgument.identifier, node);
+        LinkParentPointers(node->genericArgument.constraint, node);
         return;
 
     case GenericArguments:
@@ -1430,18 +1118,6 @@ void LinkParentPointers(Node *node, Node *prev)
         }
         return;
 
-    case GenericDeclaration:
-        LinkParentPointers(node->genericDeclaration.identifier, node);
-        LinkParentPointers(node->genericDeclaration.constraint, node);
-        return;
-
-    case GenericDeclarations:
-        for (i = 0; i < node->genericDeclarations.count; i += 1)
-        {
-            LinkParentPointers(node->genericDeclarations.declarations[i], node);
-        }
-        return;
-
     case GenericTypeNode:
         return;
 
@@ -1493,24 +1169,6 @@ void LinkParentPointers(Node *node, Node *prev)
         LinkParentPointers(node->structDeclaration.declarationSequence, node);
         return;
 
-    case StructInit:
-        LinkParentPointers(node->structInit.type, node);
-        LinkParentPointers(node->structInit.initFields, node);
-        return;
-
-    case StructInitFields:
-        for (i = 0; i < node->structInitFields.count; i += 1)
-        {
-            LinkParentPointers(node->structInitFields.fieldInits[i], node);
-        }
-        return;
-
-    case SystemCall:
-        LinkParentPointers(node->systemCall.identifier, node);
-        LinkParentPointers(node->systemCall.argumentSequence, node);
-        LinkParentPointers(node->systemCall.genericArguments, node);
-        return;
-
     case Type:
         return;
 

src/ast.h

@@ -19,11 +19,9 @@ typedef enum
     Assignment,
     BinaryExpression,
     Comment,
-    ConcreteGenericTypeNode,
     CustomTypeNode,
     Declaration,
     DeclarationSequence,
-    FieldInit,
     ForLoop,
     FunctionArgumentSequence,
     FunctionCallExpression,
@@ -33,8 +31,6 @@ typedef enum
     FunctionSignatureArguments,
     GenericArgument,
     GenericArguments,
-    GenericDeclaration,
-    GenericDeclarations,
     GenericTypeNode,
     Identifier,
     IfStatement,
@@ -48,9 +44,6 @@ typedef enum
     StaticModifier,
     StringLiteral,
     StructDeclaration,
-    StructInit,
-    StructInitFields,
-    SystemCall,
     Type,
     UnaryExpression
 } SyntaxKind;
@@ -80,8 +73,7 @@ typedef enum
     UInt,
     Float,
     Double,
-    String,
+    String
-    MemoryAddress
 } PrimitiveType;
 
 typedef union
@@ -90,16 +82,7 @@ typedef union
     BinaryOperator binaryOperator;
 } Operator;
 
-typedef struct TypeTag TypeTag;
+typedef struct TypeTag
-
-typedef struct ConcreteGenericTypeTag
-{
-    char *name;
-    TypeTag **genericArguments;
-    uint32_t genericArgumentCount;
-} ConcreteGenericTypeTag;
-
-struct TypeTag
 {
     enum Type
     {
@@ -107,8 +90,7 @@ struct TypeTag
         Primitive,
         Reference,
         Custom,
-        Generic,
+        Generic
-        ConcreteGeneric
     } type;
     union
     {
@@ -120,10 +102,8 @@ struct TypeTag
         char *customType;
         /* Valid when type = Generic. */
         char *genericType;
-        /* Valid when type = ConcreteGeneric */
-        ConcreteGenericTypeTag concreteGenericType;
     } value;
-};
+} TypeTag;
 
 typedef struct Node Node;
 
@@ -162,12 +142,6 @@ struct Node
 
         } comment;
 
-        struct
-        {
-            char *name;
-            Node *genericArguments;
-        } concreteGenericType;
-
         struct
         {
             char *name;
@@ -185,12 +159,6 @@ struct Node
             uint32_t count;
         } declarationSequence;
 
-        struct
-        {
-            Node *identifier;
-            Node *expression;
-        } fieldInit;
-
         struct
         {
             Node *declaration;
@@ -209,7 +177,6 @@ struct Node
         {
             Node *identifier; /* FIXME: need better name */
             Node *argumentSequence;
-            Node *genericArguments;
         } functionCallExpression;
 
         struct
@@ -230,7 +197,7 @@ struct Node
             Node *type;
             Node *arguments;
             Node *modifiers;
-            Node *genericDeclarations;
+            Node *genericArguments;
         } functionSignature;
 
         struct
@@ -241,7 +208,8 @@ struct Node
 
         struct
         {
-            Node *type;
+            Node *identifier;
+            Node *constraint;
         } genericArgument;
 
         struct
@@ -250,18 +218,6 @@ struct Node
             uint32_t count;
         } genericArguments;
 
-        struct
-        {
-            Node *identifier;
-            Node *constraint;
-        } genericDeclaration;
-
-        struct
-        {
-            Node **declarations;
-            uint32_t count;
-        } genericDeclarations;
-
         struct
         {
             char *name;
@@ -329,28 +285,8 @@ struct Node
         {
             Node *identifier;
             Node *declarationSequence;
-            Node *genericDeclarations;
         } structDeclaration;
 
-        struct
-        {
-            Node *type;
-            Node *initFields;
-        } structInit;
-
-        struct
-        {
-            Node **fieldInits;
-            uint32_t count;
-        } structInitFields;
-
-        struct
-        {
-            Node *identifier;
-            Node *argumentSequence;
-            Node *genericArguments;
-        } systemCall;
-
         struct
         {
             Node *typeNode;
@@ -369,11 +305,8 @@ const char *SyntaxKindString(SyntaxKind syntaxKind);
 
 uint8_t IsPrimitiveType(Node *typeNode);
 Node *MakePrimitiveTypeNode(PrimitiveType type);
-Node *MakeCustomTypeNode(Node *identifierNode);
+Node *MakeCustomTypeNode(char *string);
 Node *MakeReferenceTypeNode(Node *typeNode);
-Node *MakeConcreteGenericTypeNode(
-    Node *identifierNode,
-    Node *genericArgumentsNode);
 Node *MakeTypeNode(Node *typeNode);
 Node *MakeIdentifierNode(const char *id);
 Node *MakeNumberNode(const char *numberString);
@@ -400,21 +333,14 @@ Node *MakeFunctionSignatureNode(
 Node *MakeFunctionDeclarationNode(
     Node *functionSignatureNode,
     Node *functionBodyNode);
-Node *MakeGenericDeclarationNode(Node *identifierNode, Node *constraintNode);
+Node *MakeGenericArgumentNode(Node *identifierNode, Node *constraintNode);
-Node *MakeEmptyGenericDeclarationsNode();
-Node *StartGenericDeclarationsNode(Node *genericDeclarationNode);
-Node *AddGenericDeclaration(
-    Node *genericDeclarationsNode,
-    Node *genericDeclarationNode);
-Node *MakeGenericArgumentNode(Node *typeNode);
 Node *MakeEmptyGenericArgumentsNode();
 Node *StartGenericArgumentsNode(Node *genericArgumentNode);
 Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode);
 Node *MakeGenericTypeNode(char *name);
 Node *MakeStructDeclarationNode(
     Node *identifierNode,
-    Node *declarationSequenceNode,
+    Node *declarationSequenceNode);
-    Node *genericArgumentsNode);
 Node *StartDeclarationSequenceNode(Node *declarationNode);
 Node *AddDeclarationNode(Node *declarationSequenceNode, Node *declarationNode);
 Node *StartFunctionArgumentSequenceNode(Node *argumentNode);
@@ -422,12 +348,7 @@ Node *AddFunctionArgumentNode(Node *argumentSequenceNode, Node *argumentNode);
 Node *MakeEmptyFunctionArgumentSequenceNode();
 Node *MakeFunctionCallExpressionNode(
     Node *identifierNode,
-    Node *argumentSequenceNode,
+    Node *argumentSequenceNode);
-    Node *genericArgumentsNode);
-Node *MakeSystemCallExpressionNode(
-    Node *identifierNode,
-    Node *argumentSequenceNode,
-    Node *genericArgumentsNode);
 Node *MakeAccessExpressionNode(Node *accessee, Node *accessor);
 Node *MakeAllocNode(Node *typeNode);
 Node *MakeIfNode(Node *expressionNode, Node *statementSequenceNode);
@@ -440,11 +361,6 @@ Node *MakeForLoopNode(
     Node *startNumberNode,
     Node *endNumberNode,
     Node *statementSequenceNode);
-Node *MakeFieldInitNode(Node *identifierNode, Node *expressionNode);
-Node *StartStructInitFieldsNode(Node *fieldInitNode);
-Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode);
-Node *MakeEmptyFieldInitNode();
-Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode);
 
 void PrintNode(Node *node, uint32_t tabCount);
 const char *SyntaxKindString(SyntaxKind syntaxKind);
@@ -460,7 +376,6 @@ void LinkParentPointers(Node *node, Node *prev);
 
 TypeTag *MakeTypeTag(Node *node);
 char *TypeTagToString(TypeTag *tag);
-uint8_t TypeTagEqual(TypeTag *typeTagA, TypeTag *typeTagB);
 
 Node *LookupIdNode(Node *current, Node *prev, char *target);
 

src/util.c

@@ -5,7 +5,7 @@
 char *strdup(const char *s)
 {
     size_t slen = strlen(s);
-    char *result = (char *)malloc(sizeof(char) * (slen + 1));
+    char *result = (char *)malloc(slen + 1);
     if (result == NULL)
     {
         return NULL;
@@ -15,15 +15,6 @@ char *strdup(const char *s)
     return result;
 }
 
-char *w_strcat(char *s, char *s2)
-{
-    size_t slen = strlen(s);
-    size_t slen2 = strlen(s2);
-    s = realloc(s, sizeof(char) * (slen + slen2 + 1));
-    strcat(s, s2);
-    return s;
-}
-
 uint64_t str_hash(char *str)
 {
     uint64_t hash = 5381;

src/util.h

@@ -5,7 +5,6 @@
 #include <string.h>
 
 char *strdup(const char *s);
-char *w_strcat(char *s, char *s2);
 uint64_t str_hash(char *str);
 
 #endif /* WRAITH_UTIL_H */

src/validation.c

@@ -261,7 +261,7 @@ void ValidateIdentifiers(Node *node)
 
     /* Skip over generic arguments. They contain Identifiers but are not
      * actually identifiers, they declare types. */
-    if (node->syntaxKind == GenericDeclarations)
+    if (node->syntaxKind == GenericArguments)
         return;
 
     if (node->syntaxKind != Identifier)
@@ -309,12 +309,8 @@ void TagIdentifierTypes(Node *node)
         node->structDeclaration.identifier->typeTag = MakeTypeTag(node);
         break;
 
-    case GenericDeclaration:
+    case GenericArgument:
-        node->genericDeclaration.identifier->typeTag = MakeTypeTag(node);
+        node->genericArgument.identifier->typeTag = MakeTypeTag(node);
-        break;
-
-    case Type:
-        node->typeTag = MakeTypeTag(node);
         break;
 
     case Identifier:
@@ -355,46 +351,27 @@ Node *LookupType(Node *current, char *target)
     case FunctionDeclaration:
     {
         Node *typeArgs = current->functionDeclaration.functionSignature
-                             ->functionSignature.genericDeclarations;
+                             ->functionSignature.genericArguments;
         uint32_t i;
-        for (i = 0; i < typeArgs->genericDeclarations.count; i += 1)
+        for (i = 0; i < typeArgs->genericArguments.count; i += 1)
         {
-            Node *arg = typeArgs->genericDeclarations.declarations[i];
+            Node *arg = typeArgs->genericArguments.arguments[i];
-            Node *argId = arg->genericDeclaration.identifier;
+            Node *argId = arg->genericArgument.identifier;
             char *argName = argId->identifier.name;
-            /* note: return the GenericDeclaration, not the Identifier, so that
+            /* note: return the GenericArgument, not the Identifier, so that
              * the caller can differentiate between generics and customs. */
             if (strcmp(target, argName) == 0)
-            {
                 return arg;
         }
-        }
 
         return LookupType(current->parent, target);
     }
 
     case StructDeclaration:
     {
-        uint32_t i;
-        Node *typeArgs = current->structDeclaration.genericDeclarations;
-        for (i = 0; i < typeArgs->genericDeclarations.count; i += 1)
-        {
-            Node *arg = typeArgs->genericDeclarations.declarations[i];
-            Node *argId = arg->genericDeclaration.identifier;
-            char *argName = argId->identifier.name;
-            /* note: return the GenericDeclaration, not the Identifier, so that
-             * the caller can differentiate between generics and customs. */
-            if (strcmp(target, argName) == 0)
-            {
-                return arg;
-            }
-        }
-
         Node *structId = GetIdFromStruct(current);
         if (strcmp(target, structId->identifier.name) == 0)
-        {
             return structId;
-        }
 
         return LookupType(current->parent, target);
     }
@@ -440,8 +417,7 @@ void ConvertCustomsToGenerics(Node *node)
         {
             char *target = id->typeTag->value.customType;
             Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL &&
+            if (typeLookup != NULL && typeLookup->syntaxKind == GenericArgument)
-                typeLookup->syntaxKind == GenericDeclaration)
             {
                 id->typeTag->type = Generic;
                 free(node->declaration.type);
@@ -460,8 +436,7 @@ void ConvertCustomsToGenerics(Node *node)
         {
             char *target = id->typeTag->value.customType;
             Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL &&
+            if (typeLookup != NULL && typeLookup->syntaxKind == GenericArgument)
-                typeLookup->syntaxKind == GenericDeclaration)
             {
                 id->typeTag->type = Generic;
                 free(node->functionSignature.type);
@@ -471,22 +446,6 @@ void ConvertCustomsToGenerics(Node *node)
         }
         break;
     }
-
-    case GenericArgument:
-    {
-        Node *typeNode = node->genericArgument.type;
-        if (typeNode->typeTag->type == Custom)
-        {
-            char *target = typeNode->typeTag->value.customType;
-            Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL &&
-                typeLookup->syntaxKind == GenericDeclaration)
-            {
-                typeNode->typeTag->type = Generic;
-            }
-        }
-        break;
-    }
     }
 
     Recurse(node, *ConvertCustomsToGenerics);