Built initial foundation for polymorphism

Author: IsaacShelton

Makefile

@@ -84,7 +84,7 @@ CFLAGS=-c -Wall -I"include" $(LLVM_INCLUDE_FLAGS) -std=c99 -O0 -DNDEBUG # -fmax-
 ADDITIONAL_DEBUG_CFLAGS=-DENABLE_DEBUG_FEATURES -g # -fprofile-instr-generate -fcoverage-mapping
 LDFLAGS=$(LLVM_LINKER_FLAGS) # -fprofile-instr-generate
 SOURCES= src/AST/ast_expr.c src/AST/ast_type.c src/AST/ast.c src/AST/meta_directives.c src/BKEND/backend.c src/BKEND/ir_to_llvm.c src/BRIDGE/any.c src/BRIDGE/bridge.c src/BRIDGE/type_table.c \
-	src/BRIDGE/rtti.c src/DRVR/compiler.c src/DRVR/main.c src/DRVR/object.c src/INFER/infer.c src/IR/ir_pool.c src/IR/ir_type.c src/IR/ir.c src/IRGEN/ir_builder.c \
+	src/BRIDGE/rtti.c src/DRVR/compiler.c src/DRVR/main.c src/DRVR/object.c src/INFER/infer.c src/IR/ir_pool.c src/IR/ir_type_var.c src/IR/ir_type.c src/IR/ir.c src/IRGEN/ir_builder.c \
 	src/IRGEN/ir_gen_expr.c src/IRGEN/ir_gen_find.c src/IRGEN/ir_gen_stmt.c src/IRGEN/ir_gen_type.c src/IRGEN/ir_gen.c \
 	src/LEX/lex.c src/LEX/pkg.c src/LEX/token.c src/PARSE/parse_alias.c src/PARSE/parse_ctx.c src/PARSE/parse_dependency.c src/PARSE/parse_enum.c src/PARSE/parse_expr.c src/PARSE/parse_func.c src/PARSE/parse_global.c src/PARSE/parse_meta.c src/PARSE/parse_pragma.c \
 	src/PARSE/parse_stmt.c src/PARSE/parse_struct.c src/PARSE/parse_type.c src/PARSE/parse_util.c src/PARSE/parse.c src/UTIL/color.c src/UTIL/builtin_type.c src/UTIL/filename.c src/UTIL/levenshtein.c src/UTIL/memory.c src/UTIL/search.c src/UTIL/util.c

include/AST/ast.h

@@ -40,10 +40,11 @@ typedef struct {
 #define AST_FUNC_ARG_TYPE_TRAIT_POD TRAIT_1
 
 // Possible AST function traits
-#define AST_FUNC_FOREIGN TRAIT_1
-#define AST_FUNC_VARARG  TRAIT_2
-#define AST_FUNC_MAIN    TRAIT_3
-#define AST_FUNC_STDCALL TRAIT_4
+#define AST_FUNC_FOREIGN     TRAIT_1
+#define AST_FUNC_VARARG      TRAIT_2
+#define AST_FUNC_MAIN        TRAIT_3
+#define AST_FUNC_STDCALL     TRAIT_4
+#define AST_FUNC_POLYMORPHIC TRAIT_5
 
 // ---------------- ast_struct_t ----------------
 // A structure within the root AST
@@ -180,6 +181,10 @@ void ast_dump_enums(FILE *file, ast_enum_t *enums, length_t enums_length);
 // Fills out a blank template for a new function
 void ast_func_create_template(ast_func_t *func, strong_cstr_t name, bool is_stdcall, bool is_foreign, source_t source);
 
+// ---------------- ast_func_is_polymorphic ----------------
+// Returns whether an AST function has polymorphic arguments
+bool ast_func_is_polymorphic(ast_func_t *func);
+
 // ---------------- ast_struct_init ----------------
 // Initializes an AST struct
 void ast_struct_init(ast_struct_t *structure, strong_cstr_t name, strong_cstr_t *names, ast_type_t *types,

include/AST/ast_type.h

@@ -29,6 +29,7 @@ extern "C" {
 #define AST_ELEM_GENERIC_INT   0x05
 #define AST_ELEM_GENERIC_FLOAT 0x06
 #define AST_ELEM_FUNC          0x07
+#define AST_ELEM_POLYMORPH     0x08
 
 // Possible data flow patterns
 #define FLOW_NONE  0x00
@@ -94,6 +95,14 @@ typedef struct {
     bool ownership; // Whether or not we own our members
 } ast_elem_func_t;
 
+// ---------------- ast_elem_polymorph_t ----------------
+// Type element for a polymorphic type variable
+typedef struct {
+    unsigned int id;
+    source_t source;
+    strong_cstr_t name;
+} ast_elem_polymorph_t;
+
 // ---------------- ast_unnamed_arg_t ----------------
 // Data structure for an unnamed argument
 typedef struct {
@@ -180,6 +189,10 @@ bool ast_type_is_base_ptr_of(const ast_type_t *type, const char *base);
 // Returns whether an AST type is a pointer to another AST type
 bool ast_type_is_pointer_to(const ast_type_t *type, const ast_type_t *to);
 
+// ---------------- ast_type_has_polymorph ----------------
+// Returns whether an AST type contains a polymorphic type
+bool ast_type_has_polymorph(const ast_type_t *type);
+
 #ifdef __cplusplus
 }
 #endif

include/IR/ir.h

@@ -14,6 +14,7 @@
 #include "BRIDGE/bridge.h"
 #include "IR/ir_pool.h"
 #include "IR/ir_type.h"
+#include "IR/ir_type_var.h"
 
 // =============================================================
 // ---------------- Possible IR instruction IDs ----------------
@@ -412,9 +413,10 @@ typedef struct {
 } ir_func_t;
 
 // Possible traits for ir_func_t
-#define IR_FUNC_FOREIGN TRAIT_1
-#define IR_FUNC_VARARG  TRAIT_2
-#define IR_FUNC_STDCALL TRAIT_3
+#define IR_FUNC_FOREIGN     TRAIT_1
+#define IR_FUNC_VARARG      TRAIT_2
+#define IR_FUNC_STDCALL     TRAIT_3
+#define IR_FUNC_POLYMORPHIC TRAIT_4
 
 // ---------------- ir_func_mapping_t ----------------
 // Mapping for a name or id to AST & IR function
@@ -469,7 +471,7 @@ typedef struct {
 // ---------------- ir_shared_common_t ----------------
 // General data that can be directly accessed by the
 // entire IR module
-// 'ir_funcptr_type' -> type used for function pointer implementation
+// 'ir_funcptr' -> type used for function pointer implementation
 typedef struct {
     ir_type_t *ir_funcptr;
     ir_type_t *ir_usize;
@@ -496,6 +498,7 @@ typedef struct {
     ir_anon_global_t *anon_globals;
     length_t anon_globals_length;
     length_t anon_globals_capacity;
+    ir_type_var_stack_t type_var_stack;
 } ir_module_t;
 
 // ---------------- ir_value_str ----------------
@@ -536,5 +539,4 @@ void ir_module_free(ir_module_t *ir_module);
 // Frees data within each IR function in a list
 void ir_module_free_funcs(ir_func_t *funcs, length_t funcs_length);
 
-
 #endif // IR_H

include/IR/ir_type.h

@@ -37,7 +37,7 @@ typedef struct ir_type_t ir_type_t;
 
 struct ir_type_t {
     unsigned int kind;
-    void *extra; //
+    void *extra;
 };
 
 // ---------------- ir_type_extra_composite_t ----------------

include/IR/ir_type_var.h

@@ -0,0 +1,63 @@
+
+#ifndef IR_TYPE_VAR_H
+#define IR_TYPE_VAR_H
+
+#include "IR/ir_type.h"
+#include "UTIL/ground.h"
+
+// ---------------- ir_type_var_t ----------------
+// Polymorphic type variable
+typedef struct {
+    weak_cstr_t name;
+    ir_type_t *type;
+} ir_type_var_t;
+
+// ---------------- ir_type_var_frame_t ----------------
+// Polymorphic type variable stack frame
+typedef struct {
+    ir_type_var_t *type_vars;
+    length_t type_vars_length;
+    length_t type_vars_capacity;
+} ir_type_var_frame_t;
+
+// ---------------- ir_type_var_stack_t ----------------
+// Polymorphic type variable stack
+typedef struct {
+    ir_type_var_frame_t *frames;
+    length_t frames_length;
+    length_t frames_capacity;
+} ir_type_var_stack_t;
+
+// ---------------- ir_type_var_stack_init ----------------
+// Initializes a type variable stack
+void ir_type_var_stack_init(ir_type_var_stack_t *stack);
+
+// ---------------- ir_type_var_stack_free ----------------
+// Frees a type variable stack
+void ir_type_var_stack_free(ir_type_var_stack_t *stack);
+
+// ---------------- ir_type_var_stack_open ----------------
+// Opens a new frame in a type variable stack
+void ir_type_var_stack_open(ir_type_var_stack_t *stack);
+
+// ---------------- ir_type_var_stack_close ----------------
+// Closes the previous frame in a type variable stack
+void ir_type_var_stack_close(ir_type_var_stack_t *stack);
+
+// ---------------- ir_type_var_stack_add ----------------
+// Adds a type variable to the current stack frame
+// NOTE: Returns successful if there weren't any name collisions within
+//       the current stack frame and the type was added successfully
+successful_t ir_type_var_stack_add(ir_type_var_stack_t *stack, ir_type_var_t type_var);
+
+// ---------------- ir_type_var_frame_find ----------------
+// Finds a type variable within a single stack frame
+// NOTE: Returns NULL if non-existent
+ir_type_var_t *ir_type_var_frame_find(ir_type_var_frame_t *frame, weak_cstr_t name);
+
+// ---------------- ir_type_var_stack_find ----------------
+// Finds a type variable within a type variable stack
+// NOTE: Returns NULL if non-existent
+ir_type_var_t *ir_type_var_stack_find(ir_type_var_stack_t *stack, weak_cstr_t name);
+
+#endif // IR_TYPE_VAR_H

include/LEX/lex.h

@@ -52,6 +52,7 @@ typedef struct {
 #define LEX_STATE_UBEROR       0x00000013
 #define LEX_STATE_COLON        0x00000014
 #define LEX_STATE_META         0x00000015
+#define LEX_STATE_POLYMORPH    0x00000016
 
 // ---------------- lex ----------------
 // Entry point for lexical analysis

include/LEX/token.h

@@ -22,7 +22,7 @@ extern "C" {
     or other cases where it is necessary to break off into a new interation version.
     (Used for compatibility checking with pre-lexed libraries)
 */
-#define TOKEN_ITERATION_VERSION 0x0000000C
+#define TOKEN_ITERATION_VERSION 0x0000000D
 
 typedef unsigned short tokenid_t;
 
@@ -124,7 +124,8 @@ extern const char *global_token_name_table[];
 #define TOKEN_BIT_LGC_RSHIFT   0x00000037
 #define TOKEN_NAMESPACE        0x00000038
 #define TOKEN_META             0x00000039
-// 3A..3F
+#define TOKEN_POLYMORPH        0x0000003A
+// 3B..3F
 
 // NOTE: 0x00000040 .. 0x0000006F reserved for keywords
 // Keywords are organized as such that 0x00000040 + the id of

src/AST/ast.c

@@ -489,6 +489,13 @@ void ast_func_create_template(ast_func_t *func, strong_cstr_t name, bool is_stdc
     if(is_foreign)                func->traits |= AST_FUNC_FOREIGN;
 }
 
+bool ast_func_is_polymorphic(ast_func_t *func){
+    for(length_t i = 0; i != func->arity; i++){
+        if(ast_type_has_polymorph(&func->arg_types[i])) return true;
+    }
+    return false;
+}
+
 void ast_struct_init(ast_struct_t *structure, strong_cstr_t name, strong_cstr_t *names, ast_type_t *types,
         length_t length, trait_t traits, source_t source){
     structure->name = name;

src/AST/ast_type.c

@@ -59,6 +59,17 @@ ast_type_t ast_type_clone(const ast_type_t *original){
             ((ast_elem_func_t*) new.elements[i])->traits = ((ast_elem_func_t*) original->elements[i])->traits;
             ((ast_elem_func_t*) new.elements[i])->ownership = false;
             break;
+        case AST_ELEM_POLYMORPH: {
+                char *original_name = ((ast_elem_polymorph_t*) original->elements[i])->name;
+                length_t original_name_length = strlen(original_name);
+                char *new_name = malloc(original_name_length + 1);
+                memcpy(new_name, original_name, original_name_length + 1);
+                new.elements[i] = malloc(sizeof(ast_elem_polymorph_t));
+                ((ast_elem_polymorph_t*) new.elements[i])->id = AST_ELEM_POLYMORPH;
+                ((ast_elem_polymorph_t*) new.elements[i])->source = original->elements[i]->source;
+                ((ast_elem_polymorph_t*) new.elements[i])->name = new_name;
+                break;
+            }
         default:
             redprintf("INTERNAL ERROR: Encountered unexpected type element id when cloning ast_type_t, a crash will probably follow...\n");
         }
@@ -91,6 +102,10 @@ void ast_type_free(ast_type_t *type){
             }
             free(type->elements[i]);
             break;
+        case AST_ELEM_POLYMORPH:
+            free(((ast_elem_polymorph_t*) type->elements[i])->name);
+            free(type->elements[i]);
+            break;
         default:
             redprintf("INTERNAL ERROR: Encountered unexpected type element id when freeing ast_type_t\n");
         }
@@ -180,6 +195,18 @@ void ast_type_prepend_ptr(ast_type_t *type){
     type->elements_length++;
 }
 
+void ast_type_make_polymorph(ast_type_t *type, strong_cstr_t name){
+    ast_elem_polymorph_t *elem = malloc(sizeof(ast_elem_polymorph_t));
+    elem->id = AST_ELEM_POLYMORPH;
+    elem->name = name;
+    elem->source = NULL_SOURCE;
+
+    type->elements = malloc(sizeof(ast_elem_t*));
+    type->elements[0] = (ast_elem_t*) elem;
+    type->elements_length = 1;
+    type->source = NULL_SOURCE;
+}
+
 void ast_type_make_generic_int(ast_type_t *type){
     ast_elem_base_t *elem = malloc(sizeof(ast_elem_t));
     elem->id = AST_ELEM_GENERIC_INT;
@@ -307,6 +334,15 @@ strong_cstr_t ast_type_str(const ast_type_t *type){
                 free(type_str);
             }
             break;
+        case AST_ELEM_POLYMORPH: {
+                const char *polyname = ((ast_elem_polymorph_t*) type->elements[i])->name;
+                length_t polyname_length = strlen(polyname);
+                EXTEND_NAME_MACRO(polyname_length + 1);
+                name[name_length] = '$';
+                memcpy(&name[name_length + 1], polyname, polyname_length + 1);
+                name_length += polyname_length + 1;
+            }
+            break;
         default:
             printf("INTERNAL ERROR: Encountered unexpected element type 0x%08X when converting ast_type_t to a string\n", type->elements[i]->id);
             return NULL;
@@ -415,3 +451,29 @@ bool ast_type_is_pointer_to(const ast_type_t *type, const ast_type_t *to){
 
     return ast_types_identical(&stripped, to);
 }
+
+bool ast_type_has_polymorph(const ast_type_t *type){
+    for(length_t i = 0; i != type->elements_length; i++){
+        switch(type->elements[i]->id){
+        case AST_ELEM_BASE:
+        case AST_ELEM_POINTER:
+        case AST_ELEM_GENERIC_INT:
+        case AST_ELEM_GENERIC_FLOAT:
+        case AST_ELEM_FIXED_ARRAY:
+            break;
+        case AST_ELEM_FUNC: {
+                ast_elem_func_t *func_elem = (ast_elem_func_t*) type->elements[i];
+                for(length_t i = 0; i != func_elem->arity; i++){
+                    if(ast_type_has_polymorph(&func_elem->arg_types[i])) return true;
+                }
+                if(ast_type_has_polymorph(func_elem->return_type)) return true;
+            }
+            break;
+        case AST_ELEM_POLYMORPH:
+            return true;
+        default:
+            redprintf("INTERNAL ERROR: ast_type_has_polymorph encountered unknown element id 0x%8X", type->elements[i]->id);
+        }
+    }
+    return false;
+}