Replace visited list for pass_common with hash_set (which isn't complete, but has the basics) for a massive speedup (6xish)

stdlib/adt_lower.krak

@@ -8,13 +8,14 @@ import mem:*
 import io:*
 import ast_nodes:*
 import ast_transformation:*
+import hash_set:*
 
 import pass_common:*
 
 fun adt_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
     var type_def_option_map = map<*ast_node, vector<*ast_node>>()
-    var visited1 = set<*ast_node>()
+    var visited1 = hash_set<*ast_node>()
-    var visited2 = set<*ast_node>()
+    var visited2 = hash_set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
         var helper_before = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
             match(*node) {

stdlib/ctce_lower.krak

@@ -9,11 +9,12 @@ import io:*
 import ast_nodes:*
 import ast_transformation:*
 import interpreter:*
+import hash_set:*
 
 import pass_common:*
 
 fun ctce_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
-    var visited = set<*ast_node>()
+    var visited = hash_set<*ast_node>()
     var globals = setup_globals(*name_ast_map)
     var ctce_passes = vector<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {

stdlib/defer_lower.krak

@@ -8,12 +8,13 @@ import mem:*
 import io:*
 import ast_nodes:*
 import ast_transformation:*
+import hash_set:*
 
 import pass_common:*
 
 fun defer_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
     var enclosing_function_stack = stack<*ast_node>()
-    var visited = set<*ast_node>()
+    var visited = hash_set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
         var defer_triple_stack = stack<stack<stack<*ast_node>>>()
         var loop_stack = stack(-1)

stdlib/hash_set.krak

@@ -21,7 +21,7 @@ fun from_vector<T>(items: vector::vector<T>): hash_set<T> {
 }
 
 obj hash_set<T> (Object, Serializable) {
-    var data: hash_map::hash_map<T>
+    var data: hash_map::hash_map<T,bool>
     fun construct(): *hash_set<T> {
         data.construct()
         return this
@@ -42,10 +42,10 @@ obj hash_set<T> (Object, Serializable) {
     fun unserialize(it: ref vector::vector<char>, pos: int): int {
         return data.unserialize(it, pos)
     }
-    fun operator==(rhs: ref hash_set<T>): bool {
+    // the old unnecessary template to prevent generation
-        if (size() != rhs.size())
+    // if not used trick (in this case, changing out U with V)
-            return false
+    fun operator==<V>(other: ref hash_set<V>): bool {
-        return !data.any_true( fun(item: T): bool return !rhs.contains(item); )
+        return data == other.data
     }
     fun operator!=(rhs: ref hash_set<T>): bool {
         return ! (*this == rhs)
@@ -56,58 +56,58 @@ obj hash_set<T> (Object, Serializable) {
     fun size():int {
         return data.size
     }
-    fun contains(items: ref hash_set<T>): bool {
+    /*fun contains(items: ref hash_set<T>): bool {*/
-        return items.size() == 0 || !items.any_true( fun(item: T): bool return !contains(item); )
+        /*return items.size() == 0 || !items.any_true( fun(item: T): bool return !contains(item); )*/
-    }
+    /*}*/
     fun contains(item: ref T): bool {
         return data.contains_key(item)
     }
     fun operator+=(item: ref T) {
         add(item)
     }
-    fun operator+=(items: ref hash_set<T>) {
+    /*fun operator+=(items: ref hash_set<T>) {*/
-        add(items)
+        /*add(items)*/
-    }
+    /*}*/
-    fun operator+(items: ref hash_set<T>): hash_set<T> {
+    /*fun operator+(items: ref hash_set<T>): hash_set<T> {*/
-        var to_ret.copy_construct(this): hash_set<T>
+        /*var to_ret.copy_construct(this): hash_set<T>*/
-        to_ret.add(items)
+        /*to_ret.add(items)*/
-        return to_ret
+        /*return to_ret*/
-    }
+    /*}*/
     fun add(item: ref T) {
         if (!contains(item))
             data.set(item,true)
     }
-    fun add_all(items: ref hash_set<T>) {
+    /*fun add_all(items: ref hash_set<T>) {*/
-        add(items)
+        /*add(items)*/
-    }
+    /*}*/
-    fun add(items: ref hash_set<T>) {
+    /*fun add(items: ref hash_set<T>) {*/
-        items.for_each( fun(item: ref T) add(item); )
+        /*items.for_each( fun(item: ref T) add(item); )*/
-    }
+    /*}*/
     fun remove(item: ref T) {
         data.remove(item)
     }
-    fun for_each(func: fun(ref T):void) {
+    /*fun for_each(func: fun(ref T):void) {*/
-        data.for_each(func)
+        /*data.for_each(func)*/
-    }
+    /*}*/
-    fun for_each(func: fun(T):void) {
+    /*fun for_each(func: fun(T):void) {*/
-        data.for_each(func)
+        /*data.for_each(func)*/
-    }
+    /*}*/
-    fun any_true(func: fun(T):bool):bool {
+    /*fun any_true(func: fun(T):bool):bool {*/
-        return data.any_true(func)
+        /*return data.any_true(func)*/
-    }
+    /*}*/
-    fun reduce<U>(func: fun(T,U): U, initial: U): U {
+    /*fun reduce<U>(func: fun(T,U): U, initial: U): U {*/
-        return data.reduce(func, initial)
+        /*return data.reduce(func, initial)*/
-    }
+    /*}*/
-    fun flatten_map<U>(func: fun(T):hash_set<U>):hash_set<U> {
+    /*fun flatten_map<U>(func: fun(T):hash_set<U>):hash_set<U> {*/
-        var newSet.construct(size()): hash_set<U>
+        /*var newSet.construct(size()): hash_set<U>*/
-        for (var i = 0; i < size(); i++;)
+        /*for (var i = 0; i < size(); i++;)*/
-            func(data[i]).for_each(fun(item: ref U) newSet.add(item);)
+            /*func(data[i]).for_each(fun(item: ref U) newSet.add(item);)*/
-        return newSet
+        /*return newSet*/
-    }
+    /*}*/
-    fun filter(func: fun(T):bool):hash_set<T> {
+    /*fun filter(func: fun(T):bool):hash_set<T> {*/
-        var newSet.construct(): hash_set<T>
+        /*var newSet.construct(): hash_set<T>*/
-        newSet.data = data.filter(func)
+        /*newSet.data = data.filter(func)*/
-        return newSet
+        /*return newSet*/
-    }
+    /*}*/
 }
 

stdlib/node_counter.krak

@@ -22,7 +22,7 @@ fun node_counter_test(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>,
 }
 fun node_counter_helper(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>): int {
     var counter = 0
-    var visited = set<*ast_node>()
+    var visited = hash_set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
         var helper = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
             counter++

stdlib/obj_lower.krak

@@ -9,6 +9,7 @@ import io:*
 import ast_nodes:*
 import ast_transformation:*
 import pass_common:*
+import hash_set:*
 
 // Here's how we lower objects
 // 1 first, we make sure that all functions, if statments, while loops and for loops have code blocks
@@ -21,10 +22,10 @@ import pass_common:*
 //      temporaries.
 // 3 this is also when we add in defer destructs for function parameters (inside the function) and declaration statements
 fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
-    var visited1 = set<*ast_node>()
+    var visited1 = hash_set<*ast_node>()
-    var visited2 = set<*ast_node>()
+    var visited2 = hash_set<*ast_node>()
-    var visited3 = set<*ast_node>()
+    var visited3 = hash_set<*ast_node>()
-    var functions_visited_for_construct_in_destruct_out = set<*ast_node>()
+    var functions_visited_for_construct_in_destruct_out = hash_set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
         // Pass 1
         var ensure_block_and_munge = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
@@ -73,7 +74,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
         }
         run_on_tree(ensure_block_and_munge, empty_pass_second_half, syntax_ast_pair.second, &visited1)
         // Pass 2
-        var short_circut_op: fun(*ast_node,*stack<*ast_node>,*set<*ast_node>): bool = fun(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *set<*ast_node>): bool {
+        var short_circut_op: fun(*ast_node,*stack<*ast_node>,*hash_set<*ast_node>): bool = fun(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *hash_set<*ast_node>): bool {
             match(*node) {
                 ast_node::function_call(backing) {
                     var func_name = string()
@@ -102,9 +103,6 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
                         add_before_in(short_circuit_if, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
                         replace_with_in(node, short_circuit_result, parent_chain)
                         var shorter_tree = stack_from_vector( parent_chain->data.slice(0, parent_chain->size()-enclosing_block_idx))
-                        /*visited->add(short_circuit_result)*/
-                        /*visited->add(short_circuit_declaration)*/
-                        /*visited->add(short_circuit_if)*/
                         run_on_tree_helper(short_circut_op, empty_pass_second_half, short_circuit_declaration, &shorter_tree, visited)
                         run_on_tree_helper(short_circut_op, empty_pass_second_half, short_circuit_if, &shorter_tree, visited)
                         return false

stdlib/pass_common.krak

@@ -4,6 +4,7 @@ import util:*
 import vector:*
 import stack:*
 import string:*
+import hash_set:*
 
 fun make_this_noncached(object: *ast_node): *ast_node {
     return ast_identifier_ptr("this", object->type_def.self_type->clone_with_indirection(1), object)
@@ -404,18 +405,18 @@ fun add_after_in(to_add: *ast_node, before: *ast_node, in: *ast_node) {
     error(string("cannot add_after_in to ") + get_ast_name(in))
 }
 
-fun empty_pass_first_half(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *set<*ast_node>): bool { return true; }
+fun empty_pass_first_half(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *hash_set<*ast_node>): bool { return true; }
 fun empty_pass_second_half(node: *ast_node, parent_chain: *stack<*ast_node>) {}
-fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>):void, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *set<*ast_node>)
+fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>):void, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *hash_set<*ast_node>)
-    run_on_tree(fun(n: *ast_node, s: *stack<*ast_node>, v: *set<*ast_node>): bool {func_before(n, s);return true;}, func_after, tree, visited)
+    run_on_tree(fun(n: *ast_node, s: *stack<*ast_node>, v: *hash_set<*ast_node>): bool {func_before(n, s);return true;}, func_after, tree, visited)
 
-fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>,*set<*ast_node>):bool, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *set<*ast_node>) {
+fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>,*hash_set<*ast_node>):bool, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *hash_set<*ast_node>) {
     var parent_stack = stack<*ast_node>()
     run_on_tree_helper(func_before, func_after, tree, &parent_stack, visited)
 }
-fun run_on_tree_helper(func_before: fun(*ast_node,*stack<*ast_node>,*set<*ast_node>):bool,
+fun run_on_tree_helper(func_before: fun(*ast_node,*stack<*ast_node>,*hash_set<*ast_node>):bool,
                        func_after:  fun(*ast_node,*stack<*ast_node>):void,
-                       node: *ast_node, parent_chain: *stack<*ast_node>, visited: *set<*ast_node>) {
+                       node: *ast_node, parent_chain: *stack<*ast_node>, visited: *hash_set<*ast_node>) {
     // So some nodes should be done regardless of weather or not we've visited them - these are the places where a more reasonable AST might use bindings, i.e. variables and functions.
     if (!node || (!is_function(node) && !is_identifier(node) && visited->contains(node))) return;
     visited->add(node)

stdlib/ref_lower.krak

@@ -3,6 +3,7 @@ import tree:*
 import map:*
 import vector:*
 import set:*
+import hash_set:*
 import util:*
 import string:*
 import mem:*
@@ -40,7 +41,7 @@ fun ref_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
     var remove_ref_type_set = set<pair<string,*type>>()
     var modify_reference_use_set = set<pair<*ast_node, *ast_node>>()
     var modify_return_set = set<*ast_node>()
-    var visited = set<*ast_node>()
+    var visited = hash_set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
         var helper_before = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
             match(*node) {