Rewritten closure conversion + lifting

src/thorin/CMakeLists.txt

@@ -48,6 +48,8 @@ set(THORIN_SOURCES
     transform/codegen_prepare.cpp
     transform/dead_load_opt.cpp
     transform/dead_load_opt.h
+    transform/demote_closures.cpp
+    transform/demote_closures.h
     transform/hoist_enters.cpp
     transform/hoist_enters.h
     transform/flatten_tuples.cpp
@@ -56,8 +58,12 @@ set(THORIN_SOURCES
     transform/importer.h
     transform/inliner.cpp
     transform/inliner.h
+    transform/lift.cpp
+    transform/lift.h
     transform/lift_builtins.cpp
     transform/lift_builtins.h
+    transform/lower_closure_env.cpp
+    transform/lower_closure_env.h
     transform/mangle.cpp
     transform/mangle.h
     transform/resolve_loads.cpp

src/thorin/analyses/schedule.cpp

@@ -26,19 +26,16 @@ Scheduler::Scheduler(const Scope& s, ScopesForest& forest)
         }
     };
 
-    for (auto n : cfg().reverse_post_order()) {
-        queue.push(n->continuation());
-        auto p = done.emplace(n->continuation());
-        assert_unused(p.second);
-    }
+    assert(s.entry()->has_body());
+    done.emplace(s.entry());
+    enqueue(s.entry(), 0, s.entry()->body());
 
     while (!queue.empty()) {
         auto def = pop(queue);
         for (size_t i = 0, e = def->num_ops(); i != e; ++i) {
             // all reachable continuations have already been registered above
             // NOTE we might still see references to unreachable continuations in the schedule
-            if (!def->op(i)->isa<Continuation>())
-                enqueue(def, i, def->op(i));
+            enqueue(def, i, def->op(i));
         }
     }
 
@@ -77,7 +74,8 @@ Continuation* Scheduler::late(const Def* def) {
     } else {
         for (auto use : uses(def)) {
             auto cont = late(use);
-            result = result ? domtree().least_common_ancestor(cfg(result), cfg(cont))->continuation() : cont;
+            result = result ? forest_->least_common_ancestor(result, cont) : cont;
+            assert(result);
         }
     }
 
@@ -91,6 +89,10 @@ Continuation* Scheduler::smart(const Def* def) {
     auto l = cfg(late (def));
     auto s = l;
 
+    // if the 'early' or 'late' BB in the schedule is statically unreachable, instead emit early
+    if (!e || !l)
+        return early(def);
+
     int depth = cfg().looptree()[l]->depth();
     for (auto i = l; i != e;) {
         auto idom = domtree().idom(i);
@@ -112,11 +114,19 @@ Continuation* Scheduler::smart(const Def* def) {
     return smart_[def] = s->continuation();
 }
 
+static void add_scope_to_schedule(Schedule& sched, const Scope& s) {
+    sched.push_back(s.entry());
+    for (auto child : s.children_scopes()) {
+        add_scope_to_schedule(sched, s.forest().get_scope(child));
+    }
+}
+
 Schedule schedule(const Scope& scope) {
     // until we have sth better simply use the RPO of the CFG
     Schedule result;
     for (auto n : scope.f_cfg().reverse_post_order())
         result.emplace_back(n->continuation());
+    //add_scope_to_schedule(result, scope);
 
     return result;
 }

src/thorin/analyses/scope.cpp

@@ -323,6 +323,29 @@ ContinuationSet ScopesForest::top_level_scopes() {
     return set;
 }
 
+
+std::vector<Continuation*> ScopesForest::parent_scopes_path(Continuation* s) {
+    std::vector<Continuation*> path;
+    while (s) {
+        path.insert(path.begin(), s);
+        s = get_scope(s).parent_scope();
+    }
+    return path;
+}
+
+Continuation* ScopesForest::least_common_ancestor(Continuation* a, Continuation* b) {
+    Scope& sa = get_scope(a);
+    Scope& sb = get_scope(b);
+    auto path_a = parent_scopes_path(a);
+    auto path_b = parent_scopes_path(b);
+    Continuation* best_ancestor = nullptr;
+    for (size_t i = 0; i < path_a.size() && i < path_b.size(); i++) {
+        if (path_b[i] == path_a[i])
+            best_ancestor = path_a[i];
+    }
+    return best_ancestor;
+}
+
 template<bool elide_empty>
 void ScopesForest::for_each(std::function<void(Scope&)> f) {
     for (auto cont : top_level_scopes()) {

src/thorin/analyses/scope.h

@@ -98,6 +98,9 @@ class ScopesForest {
 
     ContinuationSet top_level_scopes();
 
+    std::vector<Continuation*> parent_scopes_path(Continuation*);
+    Continuation* least_common_ancestor(Continuation* a, Continuation* b);
+
     /**
      * Transitively visits all @em reachable Scope%s in @p world that do not have free variables.
      * We call these Scope%s @em top-level Scope%s.

src/thorin/analyses/verify.cpp

@@ -8,11 +8,19 @@ namespace thorin {
 
 // TODO this needs serious rewriting
 
-static bool verify_calls(World& world, ScopesForest&) {
+static bool verify_calls(World& world, ScopesForest& forest) {
     bool ok = true;
     for (auto def : world.defs()) {
         if (auto cont = def->isa<Continuation>())
             ok &= cont->verify();
+        if (auto closure = def->isa<Closure>()) {
+            world.VLOG("verifying closure '{}'", closure);
+            auto& scope = forest.get_scope(closure->fn());
+            if (scope.parent_scope()) {
+                world.ELOG("Closure {} has a non-top level fn: {}", closure, closure->fn());
+                ok = false;
+            }
+        }
     }
     return ok;
 }