generators/wraith.lex

@@ -14,7 +14,6 @@
 "bool"                      return BOOL;
 "MemoryAddress"             return MEMORYADDRESS;
 "struct"                    return STRUCT;
-"interface"                 return INTERFACE;
 "return"                    return RETURN;
 "static"                    return STATIC;
 "Reference"                 return REFERENCE;

generators/wraith.y

@@ -27,7 +27,6 @@ extern FILE *yyin;
 %token BOOL
 %token MEMORYADDRESS
 %token STRUCT
-%token INTERFACE
 %token RETURN
 %token STATIC
 %token REFERENCE
@@ -151,11 +150,6 @@ AccessExpression        : Identifier POINT AccessExpression
                         {
                             $$ = $1;
                         }
-						| BaseType POINT AccessExpression
-						{
-							$$ = MakeAccessExpressionNode($1, $3);
-						}
-						;
 
 SystemCallExpression    : AT Identifier
                         {
@@ -361,10 +355,6 @@ GenericDeclaration      : Identifier
                         {
                             $$ = MakeGenericDeclarationNode($1, NULL);
                         }
-                        | Identifier COLON Type
-                        {
-                            $$ = MakeGenericDeclarationNode($1, $3);
-                        }
 
 GenericDeclarations     : GenericDeclaration
                         {
@@ -443,28 +433,7 @@ Declarations            : Declaration
                             $$ = AddDeclarationNode($1, $2);
                         }
 
-InterfaceMember         : FunctionSignature SEMICOLON
+TopLevelDeclaration     : StructDeclaration;
-                        {
-                            $$ = $1;
-                        }
-
-InterfaceMembers        : InterfaceMember
-                        {
-                            $$ = StartInterfaceMembersNode($1);
-                        }
-                        | InterfaceMembers InterfaceMember
-                        {
-                            $$ = AddInterfaceMemberNode($1, $2);
-                        }
-
-InterfaceDeclaration    : INTERFACE Identifier GenericDeclarationClause LEFT_BRACE InterfaceMembers RIGHT_BRACE
-                        {
-                            $$ = MakeInterfaceDeclarationNode($2, $5, $3);
-                        }
-
-TopLevelDeclaration     : StructDeclaration
-                        | InterfaceDeclaration
-                        ;
 
 TopLevelDeclarations    : TopLevelDeclaration
                         {

generic.w

@@ -14,15 +14,6 @@ struct MemoryBlock<T>
 	start: MemoryAddress;
 	capacity: uint;
 
-	static Init(capacity: uint): MemoryBlock<T>
-	{
-		return MemoryBlock<T>
-		{
-			capacity: capacity,
-			start: @malloc(capacity * @sizeof<T>())
-		};
-	}
-
 	AddressOf(index: uint): MemoryAddress
     {
         return start + (index * @sizeof<T>());
@@ -44,40 +35,25 @@ struct MemoryBlock<T>
     }
 }
 
-struct Array<T>
-{
-    memoryBlock: MemoryBlock<T>;
-
-    static Init(capacity: uint): Array<T>
-    {
-        return Array<T>
-        {
-            memoryBlock: MemoryBlock<T>.Init(capacity)
-        };
-    }
-
-    Get(index: uint): T
-    {
-        return memoryBlock.Get(index);
-    }
-
-	Set(index: uint, value: T): void
-	{
-		memoryBlock.Set(index, value);
-	}
-}
-
 struct Program {
     static Main(): int {
-        array: Array<int> = Array<int>.Init(4);
         x: int = 4;
         y: int = Foo.Func(x);
-		array.Set(0, 2);
+        block: MemoryBlock<int> = MemoryBlock<int>
-		array.Set(1, 0);
+        {
-		array.Set(2, 5);
+            capacity: y,
-		array.Set(3, 9);
+            start: @malloc(y * @sizeof<int>())
-        Console.PrintLine("%i", array.Get(0));
+        };
-		Console.PrintLine("%i", array.Get(3));
+        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;
     }
 }

interface.w

@@ -1,30 +0,0 @@
-struct Ass
-{
-    Fart(): void
-    {
-        Console.PrintLine("Poot!");
-    }
-}
-
-interface Farter
-{
-    Fart(): void;
-}
-
-struct FartDispatcher
-{
-    static Fart<T : Farter>(farter: T): void
-    {
-        farter.Fart();
-    }
-}
-
-struct Program {
-    static Main(): int {
-        ass: Ass;
-
-        FartDispatcher.Fart(ass);
-
-        return 0;
-    }
-}

src/ast.c

@@ -612,43 +612,6 @@ Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode)
     return node;
 }
 
-Node *MakeInterfaceDeclarationNode(
-    Node *identifierNode,
-    Node *interfaceMembersNode,
-    Node *genericDeclarationsNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = Interface;
-    node->interface.identifier = identifierNode;
-    node->interface.interfaceMembers = interfaceMembersNode;
-    node->interface.genericDeclarations = genericDeclarationsNode;
-    return node;
-}
-
-Node *StartInterfaceMembersNode(Node *interfaceMemberNode)
-{
-    Node *node = (Node *)malloc(sizeof(Node));
-    node->syntaxKind = InterfaceMembers;
-    node->interfaceMembers.members = (Node **)malloc(sizeof(Node *));
-    node->interfaceMembers.members[0] = interfaceMemberNode;
-    node->interfaceMembers.count = 1;
-    return node;
-}
-
-Node *AddInterfaceMemberNode(
-    Node *interfaceMembersNode,
-    Node *interfaceMemberNode)
-{
-    interfaceMembersNode->interfaceMembers.members = realloc(
-        interfaceMembersNode->interfaceMembers.members,
-        sizeof(Node *) * (interfaceMembersNode->interfaceMembers.count + 1));
-    interfaceMembersNode->interfaceMembers
-        .members[interfaceMembersNode->interfaceMembers.count] =
-        interfaceMemberNode;
-    interfaceMembersNode->interfaceMembers.count += 1;
-    return interfaceMembersNode;
-}
-
 static const char *PrimitiveTypeToString(PrimitiveType type)
 {
     switch (type)
@@ -1386,10 +1349,6 @@ void LinkParentPointers(Node *node, Node *prev)
     case Comment:
         return;
 
-	case ConcreteGenericTypeNode:
-		LinkParentPointers(node->concreteGenericType.genericArguments, node);
-		return;
-
     case CustomTypeNode:
         return;
 
@@ -1429,7 +1388,6 @@ void LinkParentPointers(Node *node, Node *prev)
     case FunctionCallExpression:
         LinkParentPointers(node->functionCallExpression.identifier, node);
         LinkParentPointers(node->functionCallExpression.argumentSequence, node);
-		LinkParentPointers(node->functionCallExpression.genericArguments, node);
         return;
 
     case FunctionDeclaration:
@@ -1500,11 +1458,6 @@ void LinkParentPointers(Node *node, Node *prev)
         LinkParentPointers(node->ifElseStatement.elseStatement, node);
         return;
 
-	case Interface:
-		LinkParentPointers(node->interface.genericDeclarations, node);
-		LinkParentPointers(node->interface.interfaceMembers, node);
-		return;
-
     case Number:
         return;
 
@@ -1559,7 +1512,6 @@ void LinkParentPointers(Node *node, Node *prev)
         return;
 
     case Type:
-		LinkParentPointers(node->type.typeNode, node);
         return;
 
     case UnaryExpression:

src/ast.h

@@ -39,8 +39,6 @@ typedef enum
     Identifier,
     IfStatement,
     IfElseStatement,
-    Interface,
-    InterfaceMembers,
     Number,
     PrimitiveTypeNode,
     ReferenceTypeNode,
@@ -286,19 +284,6 @@ struct Node
             Node *elseStatement;
         } ifElseStatement;
 
-        struct
-        {
-            Node *identifier;
-            Node *interfaceMembers;
-            Node *genericDeclarations;
-        } interface;
-
-        struct
-        {
-            Node **members;
-            uint32_t count;
-        } interfaceMembers;
-
         struct
         {
             uint64_t value;
@@ -460,14 +445,6 @@ Node *StartStructInitFieldsNode(Node *fieldInitNode);
 Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode);
 Node *MakeEmptyFieldInitNode();
 Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode);
-Node *MakeInterfaceDeclarationNode(
-    Node *identifierNode,
-    Node *interfaceMembersNode,
-    Node *genericDeclarationsNode);
-Node *StartInterfaceMembersNode(Node *interfaceMemberNode);
-Node *AddInterfaceMemberNode(
-    Node *interfaceMembersNode,
-    Node *interfaceMemberNode);
 
 void PrintNode(Node *node, uint32_t tabCount);
 const char *SyntaxKindString(SyntaxKind syntaxKind);

src/codegen.c

@@ -111,7 +111,7 @@ struct StructTypeDeclaration
     uint32_t genericFunctionCount;
 };
 
-StructTypeDeclaration **structTypeDeclarations;
+StructTypeDeclaration *structTypeDeclarations;
 uint32_t structTypeDeclarationCount;
 
 typedef struct MonomorphizedGenericStructHashEntry
@@ -401,9 +401,9 @@ static LLVMTypeRef LookupCustomType(char *name)
 
     for (i = 0; i < structTypeDeclarationCount; i += 1)
     {
-        if (strcmp(structTypeDeclarations[i]->name, name) == 0)
+        if (strcmp(structTypeDeclarations[i].name, name) == 0)
         {
-            return structTypeDeclarations[i]->structType;
+            return structTypeDeclarations[i].structType;
         }
     }
 
@@ -420,30 +420,27 @@ static StructTypeDeclaration *AddStructDeclaration(
     uint32_t index = structTypeDeclarationCount;
     structTypeDeclarations = realloc(
         structTypeDeclarations,
-        sizeof(StructTypeDeclaration*) * (structTypeDeclarationCount + 1));
+        sizeof(StructTypeDeclaration) * (structTypeDeclarationCount + 1));
-	structTypeDeclarations[index] = malloc(sizeof(StructTypeDeclaration));
+    structTypeDeclarations[index].module = module;
-    structTypeDeclarations[index]->module = module;
+    structTypeDeclarations[index].structType = wStructType;
-    structTypeDeclarations[index]->structType = wStructType;
+    structTypeDeclarations[index].structPointerType = wStructPointerType;
-    structTypeDeclarations[index]->structPointerType = wStructPointerType;
+    structTypeDeclarations[index].name = strdup(name);
-    structTypeDeclarations[index]->name = strdup(name);
+    structTypeDeclarations[index].fields = NULL;
-    structTypeDeclarations[index]->fields = NULL;
+    structTypeDeclarations[index].fieldCount = 0;
-    structTypeDeclarations[index]->fieldCount = 0;
+    structTypeDeclarations[index].functions = NULL;
-    structTypeDeclarations[index]->functions = NULL;
+    structTypeDeclarations[index].functionCount = 0;
-    structTypeDeclarations[index]->functionCount = 0;
+    structTypeDeclarations[index].genericFunctions = NULL;
-    structTypeDeclarations[index]->genericFunctions = NULL;
+    structTypeDeclarations[index].genericFunctionCount = 0;
-    structTypeDeclarations[index]->genericFunctionCount = 0;
 
     structTypeDeclarationCount += 1;
 
-    return structTypeDeclarations[index];
+    return &structTypeDeclarations[index];
 }
 
-static MonomorphizedGenericStructHashEntry *CompileMonomorphizedGenericStruct(
+static StructTypeDeclaration *CompileMonomorphizedGenericStruct(
     GenericStructTypeDeclaration *genericStructTypeDeclaration,
     TypeTag **genericArgumentTypes,
-    uint32_t genericArgumentTypeCount,
+    uint32_t genericArgumentTypeCount)
-	MonomorphizedGenericStructHashArray *hashArray,
-	uint64_t typeHash)
 {
     uint32_t i = 0;
     uint32_t fieldCount = 0;
@@ -489,25 +486,6 @@ static MonomorphizedGenericStructHashEntry *CompileMonomorphizedGenericStruct(
 
     free(structName);
 
-	/* add entry to the hash array here in case of recursion */
-	hashArray->elements = realloc(
-		hashArray->elements,
-		sizeof(MonomorphizedGenericStructHashEntry) *
-			(hashArray->count + 1));
-	hashArray->elements[hashArray->count].key = typeHash;
-	hashArray->elements[hashArray->count].types =
-		malloc(sizeof(TypeTag *) * genericArgumentTypeCount);
-	hashArray->elements[hashArray->count].typeCount =
-		genericArgumentTypeCount;
-	hashArray->elements[hashArray->count].structDeclaration =
-		declaration;
-	for (uint32_t j = 0; j < genericArgumentTypeCount; j += 1)
-	{
-		hashArray->elements[hashArray->count].types[j] =
-			genericArgumentTypes[j];
-	}
-	hashArray->count += 1;
-
     /* first build the structure def */
     for (i = 0; i < declarationCount; i += 1)
     {
@@ -550,7 +528,7 @@ static MonomorphizedGenericStructHashEntry *CompileMonomorphizedGenericStruct(
 
     PopScopeFrame(scope);
 
-    return &hashArray->elements[hashArray->count - 1];;
+    return declaration;
 }
 
 static StructTypeDeclaration *LookupGenericStructType(
@@ -600,20 +578,38 @@ static StructTypeDeclaration *LookupGenericStructType(
 
                 if (match)
                 {
-                    hashEntry = &hashArray->elements[j];
+                    hashEntry = &hashArray->elements[i];
                     break;
                 }
             }
 
             if (hashEntry == NULL)
             {
-                hashEntry =
+                StructTypeDeclaration *structTypeDeclaration =
                     CompileMonomorphizedGenericStruct(
                         &genericStructTypeDeclarations[i],
                         genericTypeTags,
-                        typeTag->genericArgumentCount,
+                        typeTag->genericArgumentCount);
-						hashArray,
+
-						typeHash);
+                hashArray->elements = realloc(
+                    hashArray->elements,
+                    sizeof(MonomorphizedGenericStructHashEntry) *
+                        (hashArray->count + 1));
+                hashArray->elements[hashArray->count].key = typeHash;
+                hashArray->elements[hashArray->count].types =
+                    malloc(sizeof(TypeTag *) * typeTag->genericArgumentCount);
+                hashArray->elements[hashArray->count].typeCount =
+                    typeTag->genericArgumentCount;
+                hashArray->elements[hashArray->count].structDeclaration =
+                    structTypeDeclaration;
+                for (j = 0; j < typeTag->genericArgumentCount; j += 1)
+                {
+                    hashArray->elements[hashArray->count].types[j] =
+                        genericTypeTags[j];
+                }
+                hashArray->count += 1;
+
+                hashEntry = &hashArray->elements[hashArray->count - 1];
             }
 
             return hashEntry->structDeclaration;
@@ -692,9 +688,9 @@ static LLVMTypeRef LookupStructTypeByName(char *name)
 
     for (i = 0; i < structTypeDeclarationCount; i += 1)
     {
-        if (strcmp(structTypeDeclarations[i]->name, name) == 0)
+        if (strcmp(structTypeDeclarations[i].name, name) == 0)
         {
-            return structTypeDeclarations[i]->structType;
+            return structTypeDeclarations[i].structType;
         }
     }
 
@@ -707,9 +703,9 @@ static StructTypeDeclaration *LookupStructDeclaration(LLVMTypeRef structType)
 
     for (i = 0; i < structTypeDeclarationCount; i += 1)
     {
-        if (structTypeDeclarations[i]->structType == structType)
+        if (structTypeDeclarations[i].structType == structType)
         {
-            return structTypeDeclarations[i];
+            return &structTypeDeclarations[i];
         }
     }
 
@@ -728,18 +724,18 @@ static LLVMValueRef FindStructFieldPointer(
 
     for (i = 0; i < structTypeDeclarationCount; i += 1)
     {
-        if (structTypeDeclarations[i]->structPointerType == structPointerType)
+        if (structTypeDeclarations[i].structPointerType == structPointerType)
         {
-            for (j = 0; j < structTypeDeclarations[i]->fieldCount; j += 1)
+            for (j = 0; j < structTypeDeclarations[i].fieldCount; j += 1)
             {
-                if (strcmp(structTypeDeclarations[i]->fields[j].name, name) == 0)
+                if (strcmp(structTypeDeclarations[i].fields[j].name, name) == 0)
                 {
                     char *ptrName = strdup(name);
                     ptrName = w_strcat(ptrName, "_ptr");
                     return LLVMBuildStructGEP(
                         builder,
                         structPointer,
-                        structTypeDeclarations[i]->fields[j].index,
+                        structTypeDeclarations[i].fields[j].index,
                         ptrName);
                     free(ptrName);
                 }
@@ -1179,29 +1175,29 @@ static LLVMValueRef LookupFunctionByType(
 
     for (i = 0; i < structTypeDeclarationCount; i += 1)
     {
-        if (structTypeDeclarations[i]->structType == structType)
+        if (structTypeDeclarations[i].structType == structType)
         {
-            for (j = 0; j < structTypeDeclarations[i]->functionCount; j += 1)
+            for (j = 0; j < structTypeDeclarations[i].functionCount; j += 1)
             {
-                if (strcmp(structTypeDeclarations[i]->functions[j].name, name) ==
+                if (strcmp(structTypeDeclarations[i].functions[j].name, name) ==
                     0)
                 {
                     *pReturnType =
-                        structTypeDeclarations[i]->functions[j].returnType;
+                        structTypeDeclarations[i].functions[j].returnType;
-                    *pStatic = structTypeDeclarations[i]->functions[j].isStatic;
+                    *pStatic = structTypeDeclarations[i].functions[j].isStatic;
-                    return structTypeDeclarations[i]->functions[j].function;
+                    return structTypeDeclarations[i].functions[j].function;
                 }
             }
 
-            for (j = 0; j < structTypeDeclarations[i]->genericFunctionCount;
+            for (j = 0; j < structTypeDeclarations[i].genericFunctionCount;
                  j += 1)
             {
                 if (strcmp(
-                        structTypeDeclarations[i]->genericFunctions[j].name,
+                        structTypeDeclarations[i].genericFunctions[j].name,
                         name) == 0)
                 {
                     return LookupGenericFunction(
-                        &structTypeDeclarations[i]->genericFunctions[j],
+                        &structTypeDeclarations[i].genericFunctions[j],
                         functionCallExpression,
                         pReturnType,
                         pStatic);
@@ -1225,29 +1221,29 @@ static LLVMValueRef LookupFunctionByPointerType(
 
     for (i = 0; i < structTypeDeclarationCount; i += 1)
     {
-        if (structTypeDeclarations[i]->structPointerType == structPointerType)
+        if (structTypeDeclarations[i].structPointerType == structPointerType)
         {
-            for (j = 0; j < structTypeDeclarations[i]->functionCount; j += 1)
+            for (j = 0; j < structTypeDeclarations[i].functionCount; j += 1)
             {
-                if (strcmp(structTypeDeclarations[i]->functions[j].name, name) ==
+                if (strcmp(structTypeDeclarations[i].functions[j].name, name) ==
                     0)
                 {
                     *pReturnType =
-                        structTypeDeclarations[i]->functions[j].returnType;
+                        structTypeDeclarations[i].functions[j].returnType;
-                    *pStatic = structTypeDeclarations[i]->functions[j].isStatic;
+                    *pStatic = structTypeDeclarations[i].functions[j].isStatic;
-                    return structTypeDeclarations[i]->functions[j].function;
+                    return structTypeDeclarations[i].functions[j].function;
                 }
             }
 
-            for (j = 0; j < structTypeDeclarations[i]->genericFunctionCount;
+            for (j = 0; j < structTypeDeclarations[i].genericFunctionCount;
                  j += 1)
             {
                 if (strcmp(
-                        structTypeDeclarations[i]->genericFunctions[j].name,
+                        structTypeDeclarations[i].genericFunctions[j].name,
                         name) == 0)
                 {
                     return LookupGenericFunction(
-                        &structTypeDeclarations[i]->genericFunctions[j],
+                        &structTypeDeclarations[i].genericFunctions[j],
                         functionCallExpression,
                         pReturnType,
                         pStatic);
@@ -1373,31 +1369,6 @@ static LLVMValueRef CompileFunctionCallExpression(
      */
     if (functionCallExpression->functionCallExpression.identifier->syntaxKind ==
         AccessExpression)
-    {
-		if (functionCallExpression->functionCallExpression.identifier->accessExpression.accessee->syntaxKind ==
-			ConcreteGenericTypeNode)
-		{
-			TypeTag *typeTag =
-				MakeTypeTag(
-					functionCallExpression->functionCallExpression.identifier->accessExpression.accessee
-				);
-			LLVMTypeRef typeReference = ResolveType(typeTag);
-
-			char *functionName =
-				functionCallExpression->functionCallExpression.identifier
-					->accessExpression.accessor->identifier.name;
-
-			function = LookupFunctionByType(
-				typeReference,
-				functionName,
-				functionCallExpression,
-				&functionReturnType,
-				&isStatic
-			);
-
-			free(typeTag);
-		}
-		else
     {
         LLVMTypeRef typeReference = LookupStructTypeByName(
             functionCallExpression->functionCallExpression.identifier
@@ -1430,7 +1401,6 @@ static LLVMValueRef CompileFunctionCallExpression(
                 &isStatic);
         }
     }
-    }
     else if (
         functionCallExpression->functionCallExpression.identifier->syntaxKind ==
         Identifier)
@@ -1643,7 +1613,6 @@ static LLVMValueRef CompileStructInitExpression(
     LLVMTypeRef structType = ResolveType(
         ConcretizeType(structInitExpression->structInit.type->typeTag));
 
-	/* FIXME: this can be given by struct instead of allocated */
     LLVMValueRef structPointer =
         LLVMBuildAlloca(builder, structType, "structInit");
 
@@ -1659,40 +1628,19 @@ static LLVMValueRef CompileStructInitExpression(
                 .fieldInits[i]
                 ->fieldInit.identifier->identifier.name);
 
-		LLVMValueRef fieldExpressionResult = CompileExpression(
+        LLVMBuildStore(
+            builder,
+            CompileExpression(
                 structTypeDeclaration,
                 selfParam,
                 builder,
                 structInitExpression->structInit.initFields->structInitFields
                     .fieldInits[i]
-                    ->fieldInit.expression);
+                    ->fieldInit.expression),
-
-		LLVMTypeKind fieldExpressionTypeKind = LLVMGetTypeKind(LLVMTypeOf(fieldExpressionResult));
-		if (fieldExpressionTypeKind == LLVMPointerTypeKind)
-		{
-			LLVMBuildMemCpy(
-				builder,
-				structPointer,
-				LLVMGetAlignment(structPointer),
-				fieldExpressionResult,
-				LLVMGetAlignment(fieldExpressionResult),
-				LLVMSizeOf(LLVMTypeOf(fieldExpressionResult))
-			);
-		}
-		else
-		{
-			LLVMBuildStore(
-				builder,
-				fieldExpressionResult,
             structFieldPointer);
     }
-    }
 
-	return LLVMBuildLoad(
+    return structPointer;
-		builder,
-		structPointer,
-		"struct"
-	);
 }
 
 static LLVMValueRef CompileExpression(
@@ -2386,17 +2334,11 @@ static void Compile(
                 context,
                 declarationSequenceNode->declarationSequence.sequence[i]);
         }
-        else if (
-            declarationSequenceNode->declarationSequence.sequence[i]
-                ->syntaxKind == Interface)
-        {
-            /* Interfaces don't need to compile! */
-        }
         else
         {
             fprintf(
                 stderr,
-                "top level declarations that are not structs or interfaces are "
+                "top level declarations that are not structs are "
                 "forbidden!\n");
         }
     }

src/validation.c

@@ -432,41 +432,6 @@ void ConvertCustomsToGenerics(Node *node)
 
     switch (node->syntaxKind)
     {
-	case Type:
-	{
-		Node *type = node->type.typeNode;
-		if (type->syntaxKind == CustomTypeNode)
-        {
-            char *target = type->customType.name;
-            Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL &&
-                typeLookup->syntaxKind == GenericDeclaration)
-            {
-                node->typeTag->type = Generic;
-                free(node->declaration.type);
-                node->declaration.type =
-                    MakeGenericTypeNode(node->typeTag->value.genericType);
-            }
-        }
-		else if (type->syntaxKind == ConcreteGenericTypeNode)
-		{
-			for (int32_t i = 0; i < node->typeTag->value.concreteGenericType.genericArgumentCount; i += 1)
-			{
-				if (node->typeTag->value.concreteGenericType.genericArguments[i]->type == Custom)
-				{
-					char *target = node->typeTag->value.concreteGenericType.genericArguments[i]->value.customType;
-					Node *typeLookup = LookupType(node, target);
-					if (typeLookup != NULL &&
-						typeLookup->syntaxKind == GenericDeclaration)
-					{
-						node->typeTag->value.concreteGenericType.genericArguments[i]->type = Generic;
-					}
-				}
-			}
-		}
-		break;
-	}
-
     case Declaration:
     {
         Node *id = node->declaration.identifier;
@@ -484,22 +449,6 @@ void ConvertCustomsToGenerics(Node *node)
                     MakeGenericTypeNode(id->typeTag->value.genericType);
             }
         }
-		else if (type->syntaxKind == ConcreteGenericTypeNode)
-		{
-			for (int32_t i = 0; i < id->typeTag->value.concreteGenericType.genericArgumentCount; i += 1)
-			{
-				if (id->typeTag->value.concreteGenericType.genericArguments[i]->type == Custom)
-				{
-					char *target = id->typeTag->value.concreteGenericType.genericArguments[i]->value.customType;
-					Node *typeLookup = LookupType(node, target);
-					if (typeLookup != NULL &&
-						typeLookup->syntaxKind == GenericDeclaration)
-					{
-						id->typeTag->value.concreteGenericType.genericArguments[i]->type = Generic;
-					}
-				}
-			}
-		}
         break;
     }
 
@@ -519,58 +468,6 @@ void ConvertCustomsToGenerics(Node *node)
                 node->functionSignature.type =
                     MakeGenericTypeNode(id->typeTag->value.genericType);
             }
-        }
-		else if (type->syntaxKind == ConcreteGenericTypeNode)
-		{
-			for (int32_t i = 0; i < id->typeTag->value.concreteGenericType.genericArgumentCount; i += 1)
-			{
-				if (id->typeTag->value.concreteGenericType.genericArguments[i]->type == Custom)
-				{
-					char *target = id->typeTag->value.concreteGenericType.genericArguments[i]->value.customType;
-					Node *typeLookup = LookupType(node, target);
-					if (typeLookup != NULL &&
-						typeLookup->syntaxKind == GenericDeclaration)
-					{
-						id->typeTag->value.concreteGenericType.genericArguments[i]->type = Generic;
-					}
-				}
-			}
-		}
-        break;
-    }
-
-	case StructInit:
-	{
-        Node *type = node->structInit.type->type.typeNode;
-		TypeTag *typeTag = node->structInit.type->typeTag;
-        if (type->syntaxKind == CustomTypeNode)
-        {
-            char *target = typeTag->value.customType;
-            Node *typeLookup = LookupType(node, target);
-            if (typeLookup != NULL &&
-                typeLookup->syntaxKind == GenericDeclaration)
-            {
-                typeTag->type = Generic;
-                free(node->functionSignature.type);
-                node->functionSignature.type =
-                    MakeGenericTypeNode(typeTag->value.genericType);
-            }
-        }
-		else if (type->syntaxKind == ConcreteGenericTypeNode)
-		{
-			for (int32_t i = 0; i < typeTag->value.concreteGenericType.genericArgumentCount; i += 1)
-			{
-				if (typeTag->value.concreteGenericType.genericArguments[i]->type == Custom)
-				{
-					char *target = typeTag->value.concreteGenericType.genericArguments[i]->value.customType;
-					Node *typeLookup = LookupType(node, target);
-					if (typeLookup != NULL &&
-						typeLookup->syntaxKind == GenericDeclaration)
-					{
-						typeTag->value.concreteGenericType.genericArguments[i]->type = Generic;
-					}
-				}
-			}
         }
         break;
     }