Fix the rest of the test cases

Author: Victorious3

include/cstd.h

@@ -47,6 +47,16 @@ MACOS specific
 %EXCLUDE OSReadSwapInt16 OSReadSwapInt32 OSReadSwapInt64 OSWriteSwapInt16 OSWriteSwapInt32 OSWriteSwapInt64
 %EXCLUDE _OSSwapInt16 _OSSwapInt32 _OSSwapInt64 __darwin_check_fd_set __darwin_fd_clr __darwin_fd_isset
 %EXCLUDE __darwin_fd_set __sigbits __sputc
+
+ARM specific
+%EXCLUDE _ZGVnN4vv_atan2f _ZGVnN4v_acosf _ZGVnN4v_asinf _ZGVnN4v_atanf _ZGVnN4v_cosf _ZGVnN4v_expf _ZGVnN4v_exp10f _ZGVnN4v_exp2f 
+%EXCLUDE _ZGVnN4v_expm1f _ZGVnN4v_logf _ZGVnN4v_log10f _ZGVnN4v_log1pf _ZGVnN4v_log2f _ZGVnN4v_sinf _ZGVnN4v_tanf _ZGVnN2vv_atan2
+%EXCLUDE _ZGVnN2v_acos _ZGVnN2v_asin _ZGVnN2v_atan _ZGVnN2v_cos _ZGVnN2v_exp _ZGVnN2v_exp10 _ZGVnN2v_exp2 _ZGVnN2v_expm1 _ZGVnN2v_log
+%EXCLUDE _ZGVnN2v_log10 _ZGVnN2v_log1p _ZGVnN2v_log2 _ZGVnN2v_sin _ZGVnN2v_tan _ZGVsMxvv_atan2f _ZGVsMxv_acosf _ZGVsMxv_asinf
+%EXCLUDE _ZGVsMxv_atanf _ZGVsMxv_cosf _ZGVsMxv_expf _ZGVsMxv_exp10f _ZGVsMxv_exp2f _ZGVsMxv_expm1f _ZGVsMxv_logf _ZGVsMxv_log10f 
+%EXCLUDE _ZGVsMxv_log1pf _ZGVsMxv_log2f _ZGVsMxv_sinf _ZGVsMxv_tanf _ZGVsMxvv_atan2 _ZGVsMxv_acos _ZGVsMxv_asin _ZGVsMxv_atan 
+%EXCLUDE _ZGVsMxv_cos _ZGVsMxv_exp _ZGVsMxv_exp10 _ZGVsMxv_exp2 _ZGVsMxv_expm1 _ZGVsMxv_log _ZGVsMxv_log10 _ZGVsMxv_log1p 
+%EXCLUDE _ZGVsMxv_log2 _ZGVsMxv_sin _ZGVsMxv_tan
 */
 
 #include <stdlib.h>

include/gencstd.py

@@ -355,6 +355,7 @@ def to_symbol(self, n: int, file: File) -> str:
 PRIMITIVES = {
     clang.TypeKind.VOID: void,
     clang.TypeKind.CHAR_S: Integer("char"),
+    clang.TypeKind.CHAR_U: Integer("char"),
     clang.TypeKind.SCHAR: Integer("char"),
     clang.TypeKind.UCHAR: Integer("uint8"),
     clang.TypeKind.SHORT: Integer("short"),
@@ -632,7 +633,8 @@ def extract(node: clang.Cursor):
                                     file.GLOBALS[node.spelling] = ConstDecl(node.spelling, PRIMITIVES[clang.TypeKind.DOUBLE], token.spelling)
                                 except ValueError: pass
             except InvalidType as e:
-                print("Warning: Invalid type!")       
+                print(node.location)
+                print(e)     
 
         index = clang.Index.create()
         tu = index.parse(folder / f"{name}.h", args = ARGS, options = 

src/consteval.pr

@@ -896,25 +896,31 @@ export def compile_queued_functions {
     recursion_guard = true
     let debug = toolchain::debug_sym
     toolchain::debug_sym = false
-    
-    for var fdef in @function_queue.keys() {
-        let entry = function_queue(fdef)
-        
-        if not entry.node {
-            // Create dyn dispatch
-            let function = compiler::predeclare_function(fdef, const_module)
-            compiler::generate_vtable_function(function, fdef, compiler_state)
-            const_module.result.add_function(function.name, function)
-            continue
-        }
 
-        // Compile function
-        let function = compiler::create_function(entry.node, fdef, entry.node.value.def_.body, entry.node.inner_scope, null, compiler_state, params = entry.node.value.def_.params) 
-        
-        if function and function.defer_functions {
-            for var i in 0..vector::length(function.defer_functions) {
-                let deferf = function.defer_functions(i)
-                const_module.result.add_function(deferf.name, deferf)
+    // This might add new functions to the queue while compiling, so we loop until it's empty
+    while function_queue.size > 0 { 
+        for var fdef in @function_queue.keys() {
+            let entry = function_queue(fdef)
+            function_queue.remove(fdef)
+            
+            if not entry.node {
+                // Create dyn dispatch
+                // TODO This also happens for stuff like destructors and doesn't need to
+                // Just checking if the node is null doesn't work
+                let function = compiler::predeclare_function(fdef, const_module)
+                compiler::generate_vtable_function(function, fdef, compiler_state)
+                const_module.result.add_function(function.name, function)
+                continue
+            }
+
+            // Compile function
+            let function = compiler::create_function(entry.node, fdef, entry.node.value.def_.body, entry.node.inner_scope, null, compiler_state, params = entry.node.value.def_.params) 
+            
+            if function and function.defer_functions {
+                for var i in 0..vector::length(function.defer_functions) {
+                    let deferf = function.defer_functions(i)
+                    const_module.result.add_function(deferf.name, deferf)
+                }
             }
         }
     }

src/typechecking.pr

@@ -2535,6 +2535,7 @@ export def implements_interface(
         let parameter_t = vector::make(NamedParameter)
         parameter_t.push([tpe = tpe.id] !NamedParameter)
         for var param in member.parameter_t {
+            param.name = "" // We need to check based on position not name
             parameter_t.push(param)
         }
 

test/test_repl.pr

@@ -11,5 +11,5 @@ def #test test_func_call {
 }
 
 def #test test_reflection {
-    assert run_repl("int.size") == "4"
+    assert run_repl("import reflection; int.size") == "4"
 }