Add basis for types in k, and move to new poset setup (depend on individual imports, functions, types, and global variables)

k.krak

@@ -1,4 +1,3 @@
-
 import io:*
 import grammer:*
 import lexer:*
@@ -12,6 +11,7 @@ import vec_literals:*
 import poset:*
 import util:*
 import ast:*
+import type2:*
 import tree:*
 import symbol:*
 
@@ -19,6 +19,7 @@ fun main(argc: int, argv: **char): int {
     // delay construction until we either load it or copy construct it
     var gram: grammer
     var base_dir = str("/").join(str(argv[0]).split('/').slice(0,-2))
+    var import_paths =  vec(str(), base_dir + "/stdlib/")
     var file_name = base_dir + "/krakenGrammer.kgm"
     var compiled_name = file_name + str(".comp_new")
     var compiled_version = 1
@@ -82,59 +83,56 @@ fun main(argc: int, argv: **char): int {
     if (positional_args.size > 1)
         executable_name = positional_args[1]
 
-    var pass_poset = poset<pair<str, int>>()
+    var pass_poset = poset<pair<*ast, str>>()
     var name_ast_map = map<str, *tree<ast>>()
-    var import_paths =  vec(str(), base_dir + "/stdlib/")
+    var passes = map<str, fun(*ast): bool>()
-    var passes = vec<fun(str): *tree<ast>>()
+
-    passes = vec(
+    // resolves a single import
-        fun(file_name: str): *tree<ast> {
+    passes[str("import_resolver")] = fun(import_binding: *ast): bool {
-            var file = str()
+        var file_path = binding_str(import_binding)
-            for (var i = 0; i < import_paths.size; i++;) {
+        println("Running import resolver for" + file_path)
-                if (file_exists(import_paths[i] + file_name)) {
+        if (!name_ast_map.contains_key(file_path)) {
-                    if (file != "")
+            printerr(file_path + ", ")
-                        error("File: " + file_name + ", found in multiple import paths - at least two of [" + str(",").join(import_paths) + "]")
+            var parse_tree = parse.parse_input(read_file(file_path), file_path)
-                    file = read_file(import_paths[i] + file_name)
-                }
-            }
-            if (file == "")
-                error("File: " + file_name + ", not found in any import path - none of [" + str(",").join(import_paths) + "]")
-            printerr(file_name + ", ")
-            var parse_tree = parse.parse_input(file, file_name)
             trim(parse_tree)
-            return syntax_to_ast(file_name, parse_tree)
+            name_ast_map[file_path] = syntax_to_ast(file_path, parse_tree, import_paths)
-        },
+        }
-        fun(file_name: str): *tree<ast> {
+        set_bindings(import_binding, name_ast_map[file_path])
-            println("Checking for imports in " + file_name)
+
-            name_ast_map[file_name]->children.for_each(fun(n: *tree<ast>) {
+        return true
-                match (n->data) {
+    }
-                    ast::_import(b) {
+
-                        var imported_file_name = n->children[0]->data._identifier.first + ".krak"
+    // ensures that all imports reachable from this one are resolved
-                        for (var i = 0; i < passes.size; i++;) {
+    passes[str("import_checker")] = fun(import_binding: *ast): bool {
-                            if (i == 0)
+        var all_resolved = true
-                                pass_poset.add_relationship(make_pair(file_name, 2), make_pair(imported_file_name, 0))
+        var file_path = binding_str(import_binding)
-                            else
+        println("Running import checker for " + file_path)
-                                pass_poset.add_relationship(make_pair(imported_file_name, i), make_pair(imported_file_name, i-1))
+        name_ast_map[file_path]->children.for_each(fun(n: *tree<ast>) {
-                        }
+            match (n->data) {
+                ast::_import(b) {
+                    if (!bound(b.first)) {
+                        all_resolved = false
+                        pass_poset.add_relationship(make_pair(import_binding, str("import_checker")), make_pair(b.first, str("import_resolver")))
+                        println(to_string(*b.first) + " is not bound!")
+                    } else {
+                        println(to_string(*b.first) + " is bound!")
                     }
                 }
-            })
+            }
-            return name_ast_map[file_name]
+        })
-        },
+
-        fun(file_name: str): *tree<ast> {
+        return all_resolved
-            println("Doing thing 3 to " + file_name)
-            return name_ast_map[file_name]
-        }
-    )
-    for (var i = 0; i < passes.size; i++;) {
-        if (i == 0)
-            pass_poset.add_vertex(make_pair(kraken_file_name, i))
-        else
-            pass_poset.add_relationship(make_pair(kraken_file_name, i), make_pair(kraken_file_name, i-1))
     }
+
+    var top_binding = make_binding(kraken_file_name)
+    pass_poset.add_relationship(make_pair(top_binding, str("import_checker")), make_pair(top_binding, str("import_resolver")))
+
     while (pass_poset.size() != 0) {
-        var file_pass = pass_poset.pop()
+        var file_pass = pass_poset.top()
-        printlnerr("doing pass " + to_string(file_pass.second) + " on " + file_pass.first)
+        printlnerr("doing pass " + file_pass.second + " on " + to_string(*file_pass.first))
-        name_ast_map[file_pass.first] = passes[file_pass.second](file_pass.first)
+        var done = passes[file_pass.second](file_pass.first)
+        if (done)
+            pass_poset.remove(file_pass)
     }
 
     println()
@@ -160,11 +158,65 @@ fun main(argc: int, argv: **char): int {
     return 0
 }
 
-fun syntax_to_ast(file_name: str, syntax: *tree<symbol>): *tree<ast> {
+var bindings: *vec<*ast>
+fun make_binding(s: str): *ast {
+    var binding = new<ast>()->copy_construct(&ast::_binding(make_triple(s, vec<*type>(), null<tree<ast>>())))
+    if (bindings == null<vec<*ast>>())
+        bindings = new<vec<*ast>>()->construct()
+    bindings->add(binding)
+    return binding
+}
+fun set_bindings(binding: *tree<ast>, to: *tree<ast>) {
+    set_bindings(&binding->data, to)
+}
+fun set_bindings(binding: *ast, to: *tree<ast>) {
+    match(*binding) {
+        ast::_binding(b) {
+            var from = binding->_binding.third
+            // don't set null, that will set all unbound ones
+            if (from == null<tree<ast>>()) {
+                binding->_binding.third = to
+                return
+            }
+            for (var i = 0; i < bindings->size; i++;)
+                if (bindings->get(i)->_binding.third == from)
+                    bindings->get(i)->_binding.third = to
+            return
+        }
+    }
+    error("trying to set bindings on not a binding")
+}
+fun bound(binding: *ast): bool {
+    match(*binding) {
+        ast::_binding(b) return b.third != null<tree<ast>>()
+    }
+    error("Trying to check bound for not a binding")
+}
+fun binding_str(binding: *ast): str {
+    match(*binding) {
+        ast::_binding(b) return b.first
+    }
+    error("Trying to get name for not a binding")
+}
+
+fun syntax_to_ast(file_name: str, syntax: *tree<symbol>, import_paths: ref vec<str>): *tree<ast> {
+    var resolve_import_file = fun(file_name: str): str {
+        var file_path = str()
+        for (var i = 0; i < import_paths.size; i++;) {
+            if (file_exists(import_paths[i] + file_name)) {
+                if (file_path != "")
+                    error("File: " + file_name + ", found in multiple import paths - at least two of [" + str(",").join(import_paths) + "]")
+                file_path = import_paths[i] + file_name
+            }
+        }
+        if (file_path == "")
+            error("File: " + file_name + ", not found in any import path - none of [" + str(",").join(import_paths) + "]")
+        return file_path
+    }
+
     var syntax_to_ast_helper: fun(*tree<symbol>): *tree<ast> = fun(syntax: *tree<symbol>): *tree<ast> {
-        printlnerr("syntax_to_ast " + syntax->data.name)
         if (syntax->data.name == "import") {
-            return _import(from_vector(syntax->children.slice(2,-1).filter(fun(s:*tree<symbol>):bool {
+            return _import(make_binding(resolve_import_file(concat(syntax->children[1]) + ".krak")), from_vector(syntax->children.slice(2,-1).filter(fun(s:*tree<symbol>):bool {
                 return s->data.name == "identifier" || s->data.data == "*"
             }).map(concat)), vec(syntax_to_ast_helper(syntax->children[1])))
         } else if (syntax->data.name == "function")

stdlib/ast.krak

@@ -1,5 +1,5 @@
 import tree:*
-import type:*
+import type2:*
 import vec:*
 import set:*
 import util:*
@@ -8,7 +8,7 @@ import mem:*
 
 adt ast {
     _translation_unit: str,
-    _import: set<str>,
+    _import: pair<*ast, set<str>>,
     _identifier: pair<str, *type>,
     _binding: triple<str, vec<*type>, *tree<ast>>,
     _type_def: str,
@@ -35,9 +35,9 @@ adt ast {
 fun to_string(a: ref ast): str {
     match(a) {
         ast::_translation_unit(b)   return str("_translation_unit(") + b + ")"
-        ast::_import(b)             return str("_import[") + str(",").join(b.data) + "]"
+        ast::_import(b)             return str("_import(") + to_string(*b.first) + ")[" + str(",").join(b.second.data) + "]"
         ast::_identifier(b)         return str("_identifier(") + b.first + ")"
-        ast::_binding(b)            return str("_binding(") + b.first + ")"
+        ast::_binding(b)            return str("_binding(") + b.first + "->" + to_string(b.third) + ")"
         ast::_type_def(b)           return str("_type_def(") + b + ")"
         ast::_adt_def(b)            return str("_adt_def(") + b + ")"
         ast::_function(b)           return str("_function(") + b.first + ")"
@@ -63,8 +63,8 @@ fun to_string(a: ref ast): str {
 fun _translation_unit(p: str): *tree<ast> {
     return new<tree<ast>>()->construct(ast::_translation_unit(p))
 }
-fun _import(p: set<str>): *tree<ast> {
+fun _import(p1: *ast, p2: set<str>): *tree<ast> {
-    return new<tree<ast>>()->construct(ast::_import(p))
+    return new<tree<ast>>()->construct(ast::_import(make_pair(p1,p2)))
 }
 fun _type_def(p: str): *tree<ast> {
     return new<tree<ast>>()->construct(ast::_type_def(p))
@@ -141,8 +141,8 @@ fun _call(): *tree<ast> {
 fun _translation_unit(p: str, c: ref vec<*tree<ast>>): *tree<ast> {
     return new<tree<ast>>()->construct(ast::_translation_unit(p), c)
 }
-fun _import(p: set<str>, c: ref vec<*tree<ast>>): *tree<ast> {
+fun _import(p1: *ast, p2: set<str>, c: ref vec<*tree<ast>>): *tree<ast> {
-    return new<tree<ast>>()->construct(ast::_import(p), c)
+    return new<tree<ast>>()->construct(ast::_import(make_pair(p1,p2)), c)
 }
 fun _type_def(p: str, c: ref vec<*tree<ast>>): *tree<ast> {
     return new<tree<ast>>()->construct(ast::_type_def(p), c)

stdlib/ast_transformation.krak

@@ -838,14 +838,21 @@ obj ast_transformation (Object) {
             if (!possible_value) match (searching_for) {
                 search_type::function(type_vec) possible_value = find_or_instantiate_template_function(concat_symbol_tree(node->children[0]), null<tree<symbol>>(), scope, type_vec, template_replacements, map<str, *type>());
             }
-            if (!possible_value)
+            if (!possible_value) {
+                var function_error_str = str()
+                match (searching_for) {
+                    search_type::function() {
+                        function_error_str = "(" + searching_for.function.reduce(fun(n:*type, s:str):str {
+                                if (n)
+                                    return s+","+n->to_string()
+                                else
+                                    return s+",null"
+                        }, str()) + ")"
+                    }
+                }
                 error(node, concat_symbol_tree(node) + ": HAS NO POSSIBLE FUNCTION OR FUNCTION TEMPLATE SOLUTIONS\nlooking for: " +
-                    concat_symbol_tree(node->children[0]) + "(" + searching_for.function.reduce(fun(n:*type, s:str):str {
+                    concat_symbol_tree(node->children[0]) + function_error_str)
-                        if (n)
+            }
-                            return s+","+n->to_string()
-                        else
-                            return s+",null"
-                    }, str()) + ")")
             return possible_value
         } else if (node->children.size == 2) {
             var template_inst = get_node("template_inst", node)

stdlib/map.krak

@@ -66,7 +66,7 @@ obj map<T,U> (Object, Serializable) {
     fun contains_key(key: ref T): bool {
         return keys.contains(key)
     }
-    fun contains_value(value: ref U): bool {
+    fun contains_value<V>(value: ref V): bool {
         return values.contains(value)
     }
     fun get(key: ref T): ref U {
@@ -86,7 +86,7 @@ obj map<T,U> (Object, Serializable) {
             return get(key)
         return default_val
     }
-    fun reverse_get(value: ref U): ref T {
+    fun reverse_get<V>(value: ref V): ref T {
         /*return values.get(keys.find(key))*/
         var value_loc = values.find(value)
         if (value_loc == -1)

stdlib/poset.krak

@@ -48,6 +48,27 @@ obj poset<T> (Object) {
         })
         return depends_on
     }
+    fun top(): T {
+        for (var i = 0; i < adj_matrix.keys.size; i++;) {
+            if (adj_matrix.values[i].size() == 0) {
+                return adj_matrix.keys[i]
+            }
+        }
+        error("Nothing to top")
+    }
+    fun remove(x: ref T) {
+        var dependencies = adj_matrix.get_ptr_or_null(x)
+        if (dependencies == null<set<T>>())
+            error("Trying to remove item from poset that doesn't contain it!")
+        if (dependencies->size() != 0)
+            error("Trying to remove item from poset that still has dependencies on it!")
+
+        for (var j = 0; j < adj_matrix.keys.size; j++;) {
+            // remove is ok if it doesn't exist
+            adj_matrix.values[j].remove(x)
+        }
+        adj_matrix.remove(x)
+    }
     fun pop(): T {
         for (var i = 0; i < adj_matrix.keys.size; i++;) {
             if (adj_matrix.values[i].size() == 0) {

stdlib/type2.krak

@@ -0,0 +1,206 @@
+import mem:*
+import str:*
+import vec:*
+import util:*
+import ast:*
+
+adt base_type {
+    _unknown,
+    _void,
+    _object: *ast,
+    // triple<pair<param_types, return_type>, is_variadic, is raw>
+    _function: triple<pair<vec<*type>, *type>, bool, bool>,
+    _template_placeholder,
+    _bool,
+    _char,
+    _uchar,
+    _short,
+    _ushort,
+    _int,
+    _uint,
+    _long,
+    _ulong,
+    _float,
+    _double
+}
+
+obj type (Object) {
+    var base: base_type
+    var indirection: int
+    var is_ref: bool
+    fun construct(): *type {
+        base.copy_construct(&base_type::_unknown())
+        indirection = 0
+        is_ref = false
+        return this
+    }
+    fun construct(base_in: base_type, indirection_in: int, is_ref_in: bool): *type {
+        base.copy_construct(&base_in)
+        indirection = indirection_in
+        is_ref = is_ref_in
+        return this
+    }
+    fun copy_construct(old: *type) {
+        base.copy_construct(&old->base)
+        indirection = old->indirection
+        is_ref = old->is_ref
+    }
+    fun operator=(other: ref type) {
+        destruct()
+        copy_construct(&other)
+    }
+    fun destruct() {
+        base.destruct()
+    }
+    fun operator!=(other: ref type):bool return !equality(other, true);
+    fun operator==(other: ref type):bool return equality(other, true);
+    fun equality(other: *type, care_about_ref: bool):bool return equality(*other, care_about_ref);
+    fun equality(other: ref type, care_about_ref: bool):bool {
+        if (care_about_ref && (is_ref != other.is_ref))
+           return false
+        return base == other.base && indirection == other.indirection
+    }
+    fun to_string(): str {
+        var indr_string = str("")
+        if (is_ref)
+           indr_string += " ref "
+        for (var i = 0; i < indirection; i++;) indr_string += "*"
+        match (base) {
+            base_type::_unknown()               return indr_string + "_unknown"
+            base_type::_void()                  return indr_string + "_void"
+            base_type::_object(b) {
+                return indr_string + "_object"
+            }
+            base_type::_function(b) {
+                // triple<pair<param_types, return_type>, is_variadic, is raw>
+                return indr_string + "_function()"
+            }
+            base_type::_template_placeholder()  return indr_string + "_template_placeholder"
+            base_type::_bool()                  return indr_string + "_bool"
+            base_type::_char()                  return indr_string + "_char"
+            base_type::_uchar()                 return indr_string + "_uchar"
+            base_type::_short()                 return indr_string + "_short"
+            base_type::_ushort()                return indr_string + "_ushort"
+            base_type::_int()                   return indr_string + "_int"
+            base_type::_uint()                  return indr_string + "_uint"
+            base_type::_long()                  return indr_string + "_long"
+            base_type::_ulong()                 return indr_string + "_ulong"
+            base_type::_float()                 return indr_string + "_float"
+            base_type::_double()                 return indr_string + "_double"
+        }
+        return str("impossible type, indirection:") + indirection
+    }
+    fun is_unknown(): bool {
+        match (base) {
+            base_type::_unknown() return true
+        }
+        return false
+    }
+    fun is_void(): bool {
+        match (base) {
+            base_type::_void() return true
+        }
+        return false
+    }
+    fun is_object(): bool {
+        match (base) {
+            base_type::_object() return true
+        }
+        return false
+    }
+    fun is_function(): bool {
+        match (base) {
+            base_type::_function() return true
+        }
+        return false
+    }
+    fun is_template_placeholder(): bool {
+        match (base) {
+            base_type::_template_placeholder() return true
+        }
+        return false
+    }
+    fun is_bool(): bool {
+        match (base) {
+            base_type::_bool() return true
+        }
+        return false
+    }
+    fun is_char(): bool {
+        match (base) {
+            base_type::_char() return true
+        }
+        return false
+    }
+    fun is_uchar(): bool {
+        match (base) {
+            base_type::_uchar() return true
+        }
+        return false
+    }
+    fun is_short(): bool {
+        match (base) {
+            base_type::_short() return true
+        }
+        return false
+    }
+    fun is_ushort(): bool {
+        match (base) {
+            base_type::_ushort() return true
+        }
+        return false
+    }
+    fun is_int(): bool {
+        match (base) {
+            base_type::_int() return true
+        }
+        return false
+    }
+    fun is_uint(): bool {
+        match (base) {
+            base_type::_uint() return true
+        }
+        return false
+    }
+    fun is_long(): bool {
+        match (base) {
+            base_type::_long() return true
+        }
+        return false
+    }
+    fun is_ulong(): bool {
+        match (base) {
+            base_type::_ulong() return true
+        }
+        return false
+    }
+    fun is_float(): bool {
+        match (base) {
+            base_type::_float() return true
+        }
+        return false
+    }
+    fun is_double(): bool {
+        match (base) {
+            base_type::_double() return true
+        }
+        return false
+    }
+    fun is_signed(): bool {
+        match (base) {
+            base_type::_char()      return true
+            base_type::_int()       return true
+            base_type::_long()      return true
+            base_type::_short()     return true
+            base_type::_float()     return true
+            base_type::_double()    return true
+
+            base_type::_uchar()     return false
+            base_type::_ushort()    return false
+            base_type::_uint()      return false
+            base_type::_ulong()     return false
+        }
+        return false
+    }
+}
+