Various fixes

UplinkCoder · UplinkCoder · commit b55d5e376cd4 · 2024-11-09T02:53:53.000+01:00
diff --git a/parser/metac_parser.c b/parser/metac_parser.c
@@ -1617,7 +1617,7 @@ uint32_t HashDecl(metac_decl_t* decl)
                     result = CRC32C_VALUE(result, fieldHash);
                     field = field->Next;
                 }
-                assert(field->Next = cast(decl_field_t*)emptyPointer);
+                assert(field->Next == cast(decl_field_t*)emptyPointer);
             }
         } break;
         case decl_variable:
@@ -1929,7 +1929,6 @@ metac_decl_t* MetaCParser_ParseDecl(metac_parser_t* self, metac_decl_t* parent)
                     functionType->ReturnType = returnType;
                     hash = CRC32C_VALUE(hash, returnType->Hash);
                     functionType->ParameterCount = paramterList.ParameterCount;
-                    const uint32_t pCount = functionType->ParameterCount;
                     hash = CRC32C_VALUE(hash, functionType->ParameterCount);
                     functionType->Parameters = paramterList.List;
                     hash = CRC32C_VALUE(hash, paramterList.Hash);
diff --git a/repl/completion_trie.c b/repl/completion_trie.c
@@ -106,7 +106,7 @@ void CompletionTrie_Collect(completion_trie_root_t* root,
     uint32_t currentUnmatchedPrefixLength = unmatchedPrefixLength;
     bool descend = true;
 
-    memcpy(completionString + completionLength, prefix, matchedUntil);
+    memcpy(completionString, prefix, matchedUntil);
 
     for (;;) // until we are back at the root and there are no children left
 LSetCurrent:
@@ -524,9 +524,10 @@ void CompletionTrie_PrintRanges(completion_trie_root_t* self)
     fclose(f);
 }
 #endif
-void CompletionTrie_PrintStats(completion_trie_root_t* self)
+
+void CompletionTrie_PrintTrie(completion_trie_root_t* self)
 {
-    {
+        ALIGN_STACK();
         FILE* f = fopen("g.dot", "w");
         fprintf(f, "digraph G {\n");
         fprintf(f, "  node [shape=record headport=n]\n");
@@ -535,7 +536,12 @@ void CompletionTrie_PrintStats(completion_trie_root_t* self)
 
         fprintf(f, "}\n");
         fclose(f);
-    }
+        RESTORE_STACK();
+}
+
+void CompletionTrie_PrintStats(completion_trie_root_t* self)
+{
+    CompletionTrie_PrintTrie(self);
 
     printf("UsedNodes: %u\n", self->TotalNodes);
     printf("AllocatedNodes: %u\n", self->NodesCount);
diff --git a/semantic/metac_scope.h b/semantic/metac_scope.h
@@ -7,27 +7,27 @@
 
 struct metac_sema_decl_t;
 
+#define FOREACH_SCOPE_OWNER(M) \
+    M(scope_owner_unknown   , 0x0) \
+    /* unused for now */ \
+    M(scope_owner_module    , 0x1) \
+    M(scope_owner_function  , 0x2) \
+    M(scope_owner_struct    , 0x3) \
+    M(scope_owner_statement , 0x4) \
+    M(scope_owner_block     , 0x5) \
+    M(scope_owner_union     , 0x6) \
+    M(scope_owner_extended  , 0x7) \
+    M(scope_owner_enum      , 0x9) \
+    M(scope_owner_template  , 0xA) \
+    /* 0xF is for invalid reserved. */ \
+    M(scope_owner_invalid  , 0xF)
+
+#define DEF_MEMBER(NAME, VALUE) \
+    NAME = VALUE,
+
 typedef enum metac_scope_owner_kind_t
 {
-    scope_owner_unknown   = 0x0,
-
-    /// unused for now
-    scope_owner_module    = 0x1,
-
-    scope_owner_function  = 0x2,
-    scope_owner_struct    = 0x3,
-    scope_owner_statement = 0x4,
-    scope_owner_block     = 0x5,
-
-    scope_owner_union     = 0x6,
-
-    scope_owner_extended  = 0x7,
-
-    scope_owner_enum      = 0x9,
-
-    // unused range A-D A, B, C, D
-    scope_owner_invalid  = 0xF
-
+    FOREACH_SCOPE_OWNER(DEF_MEMBER)
 } metac_scope_owner_kind_t;
 
 
diff --git a/semantic/metac_semantic.c b/semantic/metac_semantic.c
@@ -1061,6 +1061,8 @@ metac_type_t NodeFromTypeIndex(metac_sema_state_t* sema,
             return cast(metac_type_t) FunctiontypePtr(sema, index);
         case type_index_array:
             return cast(metac_type_t) ArrayTypePtr(sema, index);
+        case type_index_template:
+            return cast(metac_type_t) TemplateTypePtr(sema, index);
     }
 
     return 0;
diff --git a/semantic/metac_type_semantic.c b/semantic/metac_type_semantic.c
@@ -63,16 +63,18 @@ static inline bool isBasicType(metac_type_kind_t typeKind)
 bool IsUnknownType(metac_sema_state_t* self,
                    metac_type_index_t typeIndex)
 {
+    bool result = false;
+
     if (TYPE_INDEX_KIND(typeIndex) == type_index_unknown)
     {
-        return true;
+        result = true;
     }
     if (TYPE_INDEX_KIND(typeIndex) == type_index_array)
     {
-        return IsUnknownType(self, self->ArrayTypeTable.Slots[TYPE_INDEX_INDEX(typeIndex)].TypeIndex);
+        result = IsUnknownType(self, self->ArrayTypeTable.Slots[TYPE_INDEX_INDEX(typeIndex)].TypeIndex);
     }
 
-    return false;
+    return result;
 }
 
 sema_decl_type_t* MetaCSemantic_GetTypeNode(metac_sema_state_t* self,
@@ -346,6 +348,7 @@ metac_type_index_t MetaCSemantic_GetElementType(metac_sema_state_t* self,
             metac_type_ptr_t* ptrType = PtrTypePtr(self, TYPE_INDEX_INDEX(typeIndex));
             result = ptrType->ElementType;
         } break;
+        default:
     }
 
     return result;
@@ -1178,16 +1181,22 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,
                         placeholder->Kind = expr_unknown_value;
                         placeholder->TypeIndex = MetaCSemantic_TypeSemantic(self, param->Parameter->VarType);
                         METAC_NODE(placeholder->Expr) = emptyNode;
+                        placeholder->LocationIdx = locIdx;
 
 
-                        MetaCSemantic_RegisterInScope(self, paramIdent, placeholder);
+                        MetaCSemantic_RegisterInScope(self, paramIdent, METAC_NODE(placeholder));
 
                         param = param->Next;
                     }
                 }
 
                 MetaCSemantic_ComputeStructLayout(self, agg, tmpSemaAgg);
 
+                if (agg->ParameterCount != 0)
+                {
+                    MetaCSemantic_PopTemporaryScope(self);
+                }
+
                 MetaCSemantic_UnmountScope(self);
 
                 hash = AggregateHash(tmpSemaAgg);
@@ -1313,7 +1322,7 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,
         {
             metac_decl_t* symbol = NULL;
             metac_expr_t* arguments = cast(metac_expr_t*) emptyNode;
-            uint32_t hash = crc32c_nozero(~0, &symbol->Hash, sizeof(symbol->Hash));
+            uint32_t hash = symbol ? crc32c_nozero(~0, &symbol->Hash, sizeof(symbol->Hash)) : ~0;
             uint32_t nArguments = 0;
             for(uint32_t argIdx = 0; argIdx < nArguments; argIdx++)
             {
@@ -1331,7 +1340,7 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,
                 result = MetaCTypeTable_GetOrEmptyTemplateType(&self->TemplateTypeTable, &key);
                 if (result.v == 0)
                 {
-                    MetaCTypeTable_AddTemplateType(&self->TemplateTypeTable, &key);
+                    result = MetaCTypeTable_AddTemplateType(&self->TemplateTypeTable, &key);
                 }
             }
 
@@ -1648,7 +1657,7 @@ bool MetaCSemantic_ComputeStructLayout(metac_sema_state_t* self,
 #ifndef NO_FIBERS
         while (!semaField->Type.v)
         {
-            printf("FieldType couldn't be resolved ... yielding fiber\n");
+            xprintf("FieldType couldn't be resolved ... yielding fiber\n");
             aco_t* me = (aco_t*)CurrentFiber();
             if (me != 0)
             {
@@ -1659,11 +1668,11 @@ bool MetaCSemantic_ComputeStructLayout(metac_sema_state_t* self,
 
                 assert(self->Waiters.WaiterCount < self->Waiters.WaiterCapacity);
                 self->Waiters.Waiters[self->Waiters.WaiterCount++] = waiter;
-                printf("We should Yield\n");
+                xprintf("We should Yield\n");
                 (cast(task_t*)(me->arg))->TaskFlags = Task_Waiting;
                 YIELD(watingOnTypeSemantic);
                 (cast(task_t*)(me->arg))->TaskFlags = Task_Running;
-                printf("Now we should be able to resolve\n");
+                xprintf("Now we should be able to resolve\n");
                 semaField->Type =
                     MetaCSemantic_doTypeSemantic(self, declField->Field->VarType);
             }
diff --git a/semantic/node_alloc.c b/semantic/node_alloc.c
@@ -106,6 +106,12 @@ metac_type_array_t* ArrayTypePtr(metac_sema_state_t* self, uint32_t index)
     return result;
 }
 
+metac_type_template_t* TemplateTypePtr(metac_sema_state_t* self, uint32_t index)
+{
+    metac_type_template_t* result = (self->TemplateTypeTable.Slots + index);
+    return result;
+}
+
 metac_type_functiontype_t* FunctiontypePtr(metac_sema_state_t* self, uint32_t index)
 {
     metac_type_functiontype_t* result = (self->FunctionTypeTable.Slots + index);

Original file line number	Diff line number	Diff line change
`@@ -1061,6 +1061,8 @@ metac_type_t NodeFromTypeIndex(metac_sema_state_t* sema,`
`1061`	`1061`	`return cast(metac_type_t) FunctiontypePtr(sema, index);`
`1062`	`1062`	`case type_index_array:`
`1063`	`1063`	`return cast(metac_type_t) ArrayTypePtr(sema, index);`
	`1064`	`+ case type_index_template:`
	`1065`	`+ return cast(metac_type_t) TemplateTypePtr(sema, index);`
`1064`	`1066`	`}`
`1065`	`1067`
`1066`	`1068`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -63,16 +63,18 @@ static inline bool isBasicType(metac_type_kind_t typeKind)`
`63`	`63`	`bool IsUnknownType(metac_sema_state_t* self,`
`64`	`64`	`metac_type_index_t typeIndex)`
`65`	`65`	`{`
	`66`	`+ bool result = false;`
	`67`	`+`
`66`	`68`	`if (TYPE_INDEX_KIND(typeIndex) == type_index_unknown)`
`67`	`69`	`{`
`68`		`- return true;`
	`70`	`+ result = true;`
`69`	`71`	`}`
`70`	`72`	`if (TYPE_INDEX_KIND(typeIndex) == type_index_array)`
`71`	`73`	`{`
`72`		`- return IsUnknownType(self, self->ArrayTypeTable.Slots[TYPE_INDEX_INDEX(typeIndex)].TypeIndex);`
	`74`	`+ result = IsUnknownType(self, self->ArrayTypeTable.Slots[TYPE_INDEX_INDEX(typeIndex)].TypeIndex);`
`73`	`75`	`}`
`74`	`76`
`75`		`- return false;`
	`77`	`+ return result;`
`76`	`78`	`}`
`77`	`79`
`78`	`80`	`sema_decl_type_t* MetaCSemantic_GetTypeNode(metac_sema_state_t* self,`
`@@ -346,6 +348,7 @@ metac_type_index_t MetaCSemantic_GetElementType(metac_sema_state_t* self,`
`346`	`348`	`metac_type_ptr_t* ptrType = PtrTypePtr(self, TYPE_INDEX_INDEX(typeIndex));`
`347`	`349`	`result = ptrType->ElementType;`
`348`	`350`	`} break;`
	`351`	`+ default:`
`349`	`352`	`}`
`350`	`353`
`351`	`354`	`return result;`
`@@ -1178,16 +1181,22 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,`
`1178`	`1181`	`placeholder->Kind = expr_unknown_value;`
`1179`	`1182`	`placeholder->TypeIndex = MetaCSemantic_TypeSemantic(self, param->Parameter->VarType);`
`1180`	`1183`	`METAC_NODE(placeholder->Expr) = emptyNode;`
	`1184`	`+ placeholder->LocationIdx = locIdx;`
`1181`	`1185`
`1182`	`1186`
`1183`		`- MetaCSemantic_RegisterInScope(self, paramIdent, placeholder);`
	`1187`	`+ MetaCSemantic_RegisterInScope(self, paramIdent, METAC_NODE(placeholder));`
`1184`	`1188`
`1185`	`1189`	`param = param->Next;`
`1186`	`1190`	`}`
`1187`	`1191`	`}`
`1188`	`1192`
`1189`	`1193`	`MetaCSemantic_ComputeStructLayout(self, agg, tmpSemaAgg);`
`1190`	`1194`
	`1195`	`+ if (agg->ParameterCount != 0)`
	`1196`	`+ {`
	`1197`	`+ MetaCSemantic_PopTemporaryScope(self);`
	`1198`	`+ }`
	`1199`	`+`
`1191`	`1200`	`MetaCSemantic_UnmountScope(self);`
`1192`	`1201`
`1193`	`1202`	`hash = AggregateHash(tmpSemaAgg);`
`@@ -1313,7 +1322,7 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,`
`1313`	`1322`	`{`
`1314`	`1323`	`metac_decl_t* symbol = NULL;`
`1315`	`1324`	`metac_expr_t* arguments = cast(metac_expr_t*) emptyNode;`
`1316`		`- uint32_t hash = crc32c_nozero(~0, &symbol->Hash, sizeof(symbol->Hash));`
	`1325`	`+ uint32_t hash = symbol ? crc32c_nozero(~0, &symbol->Hash, sizeof(symbol->Hash)) : ~0;`
`1317`	`1326`	`uint32_t nArguments = 0;`
`1318`	`1327`	`for(uint32_t argIdx = 0; argIdx < nArguments; argIdx++)`
`1319`	`1328`	`{`
`@@ -1331,7 +1340,7 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,`
`1331`	`1340`	`result = MetaCTypeTable_GetOrEmptyTemplateType(&self->TemplateTypeTable, &key);`
`1332`	`1341`	`if (result.v == 0)`
`1333`	`1342`	`{`
`1334`		`- MetaCTypeTable_AddTemplateType(&self->TemplateTypeTable, &key);`
	`1343`	`+ result = MetaCTypeTable_AddTemplateType(&self->TemplateTypeTable, &key);`
`1335`	`1344`	`}`
`1336`	`1345`	`}`
`1337`	`1346`
`@@ -1648,7 +1657,7 @@ bool MetaCSemantic_ComputeStructLayout(metac_sema_state_t* self,`
`1648`	`1657`	`#ifndef NO_FIBERS`
`1649`	`1658`	`while (!semaField->Type.v)`
`1650`	`1659`	`{`
`1651`		`- printf("FieldType couldn't be resolved ... yielding fiber\n");`
	`1660`	`+ xprintf("FieldType couldn't be resolved ... yielding fiber\n");`
`1652`	`1661`	`aco_t* me = (aco_t*)CurrentFiber();`
`1653`	`1662`	`if (me != 0)`
`1654`	`1663`	`{`
`@@ -1659,11 +1668,11 @@ bool MetaCSemantic_ComputeStructLayout(metac_sema_state_t* self,`
`1659`	`1668`
`1660`	`1669`	`assert(self->Waiters.WaiterCount < self->Waiters.WaiterCapacity);`
`1661`	`1670`	`self->Waiters.Waiters[self->Waiters.WaiterCount++] = waiter;`
`1662`		`- printf("We should Yield\n");`
	`1671`	`+ xprintf("We should Yield\n");`
`1663`	`1672`	`(cast(task_t*)(me->arg))->TaskFlags = Task_Waiting;`
`1664`	`1673`	`YIELD(watingOnTypeSemantic);`
`1665`	`1674`	`(cast(task_t*)(me->arg))->TaskFlags = Task_Running;`
`1666`		`- printf("Now we should be able to resolve\n");`
	`1675`	`+ xprintf("Now we should be able to resolve\n");`
`1667`	`1676`	`semaField->Type =`
`1668`	`1677`	`MetaCSemantic_doTypeSemantic(self, declField->Field->VarType);`
`1669`	`1678`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,12 @@ metac_type_array_t* ArrayTypePtr(metac_sema_state_t* self, uint32_t index)`
`106`	`106`	`return result;`
`107`	`107`	`}`
`108`	`108`
	`109`	`+metac_type_template_t* TemplateTypePtr(metac_sema_state_t* self, uint32_t index)`
	`110`	`+{`
	`111`	`+ metac_type_template_t* result = (self->TemplateTypeTable.Slots + index);`
	`112`	`+ return result;`
	`113`	`+}`
	`114`	`+`
`109`	`115`	`metac_type_functiontype_t* FunctiontypePtr(metac_sema_state_t* self, uint32_t index)`
`110`	`116`	`{`
`111`	`117`	`metac_type_functiontype_t* result = (self->FunctionTypeTable.Slots + index);`