wip

Author: wbbradley

lib/map.zion

@@ -1,17 +1,12 @@
 # Implements the default Map type in Zion
 
 import list {List, Cons, Nil, remove_if}
-import hash {hash}
-import copy {Copy, copy}
 export {Map, MapStorage, keys, values, from_pairs}
 
 newtype MapKeyValueCell key value = MapKeyValueCell(Int, key, var value)
 newtype MapStorage key value = MapStorage([List (MapKeyValueCell key value)])
 newtype Map key value = Map(MapStorage key value, var Int)
 
-fn str_tuple_show(key, value) => "${repr(key)}: ${value}"
-fn repr_tuple_show(key, value) => "${repr(key)}: ${repr(value)}"
-
 fn map_render(map, tuple_show) {
   let Map(MapStorage(storage), _) = map
   let results = []
@@ -39,6 +34,9 @@ instance Repr (Map key value) {
   fn repr(map) => map_render(map, repr_tuple_show)
 }
 
+fn str_tuple_show(key, value) => "${repr(key)}: ${value}"
+fn repr_tuple_show(key, value) => "${repr(key)}: ${repr(value)}"
+
 instance HasSetMembership (Map key value) key {
   fn in(key, map) Bool {
     let Map(map_storage, var size) = map

lib/std.zion

@@ -3,8 +3,8 @@ import append {MutatingAppend, append}
 import result {Result, Ok, Err}
 import defaults {HasDefault, HasDefaultGet, new, get}
 import maybe {Maybe, Nothing, Just}
-import map {Map, keys, values}
 import math {+, -, *, /, abs, negate, Num, Bounded, from_int, identity}
+import map {Map, keys, values}
 import set {Set, set}
 import sys {open, read, write, close, readlines, stdin, stdout, stderr}
 import vector {Vector, flatten, reserve, vector, reset, resize}
@@ -23,7 +23,19 @@ export {String, split, chomp, strip, concat, has_substring, has_prefix, has_suff
         join}
 export {Result, Ok, Err}
 export {u8, i8}
-# export {nothing}
+export {Eq, ==, !=}
+export {Iterable, iter, nothing}
+export {not, True, False, Str, str, alloc}
+export {HasLength, len}
+export {Modular, %}
+export {Range, range, Ref}
+export {HasInsertableItems, insert, remove}
+export {compare, <, <=, >, >=, min, max}
+export {isspace, isdigit, isalpha, islower, isupper, tolower, toupper}
+export {pointer_subtraction, strlen, |}
+export {Either, Left, Right, serialize}
+export {any, all, not_in}
+export {print, int, float}
 
 link pkg "bdw-gc"
 
@@ -813,7 +825,7 @@ instance Serializeable Buffer {
     serialize = id
 }
 
-fn __ptr_sub(p1 *Char, p2 *Char) Int {
+fn pointer_subtraction(p1 *Char, p2 *Char) Int {
   return (p1 as! Int) - (p2 as! Int)
 }
 

lib/string.zion

@@ -352,10 +352,10 @@ fn split(input String, delim String) [String] {
       append(result, String(cur_big, big_len_left))
       return result
     } else {
-      append(result, String(cur_big, __ptr_sub(next_little, cur_big)))
+      append(result, String(cur_big, pointer_subtraction(next_little, cur_big)))
 
       cur_big = __builtin_ptr_add(next_little, little_len)
-      big_len_left = orig_big_len - __ptr_sub(cur_big, orig_big)
+      big_len_left = orig_big_len - pointer_subtraction(cur_big, orig_big)
       if big_len_left == 0 {
         append(result, "")
         return result

lib/sys.zion

@@ -1,4 +1,5 @@
 import bufio {BufferedFileIO}
+
 export {
   get_args, FileDescriptor, File, open, close, unlink, read, stdin, stdout,
   stderr, Errno, get_errno, write, BufferedFileIO, readlines, CreateMode,

local.vimrc

@@ -5,6 +5,7 @@ autocmd FileType c nnoremap <F4> :wa<CR> :e %:p:s,.h$,.X123X,:s,.cpp$,.h,:s,.X12
 autocmd FileType c inoremap <F4> <Esc> <F4>
 autocmd FileType c vnoremap <F4> <Esc> <F4>
 nnoremap <Leader>` :echom system("./zion-tags\ .")<CR>
+autocmd FileType * setlocal makeprg=make\ debug
 let &path=substitute(
       \ system('pkg-config bdw-gc --variable=includedir'),
       \ '\n', '', 'g') . ',.'

src/builtins.cpp

@@ -1,8 +1,8 @@
 #include "builtins.h"
 #include "tld.h"
 
-std::string ARROW_TYPE_OPERATOR = "->";
-std::string PTR_TYPE_OPERATOR = "*";
+std::string ARROW_TYPE_OPERATOR = zion::tld::mktld("std", "->");
+std::string PTR_TYPE_OPERATOR = zion::tld::mktld("std", "*");
 std::string REF_TYPE_OPERATOR = zion::tld::mktld("std", "Ref");
 
 std::string CHAR_TYPE = "Char";

src/colors.h

@@ -38,7 +38,7 @@
 #define _bright_green(x) _COLOR(_ANSI_COLOR_BRIGHT_GREEN, x)
 
 /* Semantic coloring helpers */
-#define C_MODULE _ANSI_COLOR_MAGENTA
+#define C_MODULE _ANSI_COLOR_GREEN
 #define C_LINE_REF _ANSI_COLOR_DIM
 #define C_ID _ANSI_COLOR_MAGENTA
 #define C_CONTROL _ANSI_COLOR_CYAN

src/compiler.cpp

@@ -184,7 +184,7 @@ struct GlobalParserState {
       modules_map_by_name[ps.module_name] = module;
       modules_map_by_filename[ps.filename] = module;
 
-      debug_above(8, log("while parsing %s got dependencies {%s}",
+      debug_above(8, log("while parsing %s got module dependencies {%s}",
                          ps.module_name.c_str(),
                          join(dependencies, ", ").c_str()));
       for (auto dependency : dependencies) {
@@ -230,10 +230,12 @@ std::set<std::string> get_top_level_decls(
       top_level_decls.insert(overload_pair.first);
     }
   }
+  /*
   for (auto &import : imports) {
-    assert(tld::is_fqn(import.name, true /*default_special*/));
+    assert(tld::is_fqn(import.name));
     top_level_decls.insert(import.name);
   }
+  */
   debug_above(8, log("tlds are %s", ::join(top_level_decls, ", ").c_str()));
   return top_level_decls;
 }
@@ -259,13 +261,14 @@ std::shared_ptr<Compilation> merge_compilation(
         module->imports);
 
     std::set<std::string> bindings;
+    log("bindings for %s", module->name.c_str());
     for (auto binding: maybe_not_tld_bindings) {
       bindings.insert(binding);
       bindings.insert(tld::tld(binding));
+      log("bindings += %s", binding.c_str());
     }
     const Module *module_rebound = prefix(bindings, module);
 
-
     /* now all locally referring vars are fully qualified */
     for (const Decl *decl : module_rebound->decls) {
       program_decls.push_back(decl);
@@ -343,7 +346,9 @@ Compilation::ref parse_program(
     debug_above(11, log(log_info, "parse_module of %s succeeded",
                         module_name.c_str(), false /*global*/));
 
-    /* find the import rewriting rules */
+    /* find the import rewriting rules. this finds the final transitive
+     * endpoint of any aliasing edges in the graph of import/exports, and
+     * rewrites all non-leaf nodes as the leaf (endpoint) node. */
     RewriteImportRules rewriting_imports_rules = solve_rewriting_imports(
         gps.symbol_imports, gps.symbol_exports);
 

src/import_rules.cpp

@@ -11,24 +11,62 @@ RewriteImportRules solve_rewriting_imports(
     const parser::SymbolExports &symbol_exports) {
   std::map<Identifier, Identifier> graph;
   std::set<std::string> legal_exports;
+
 #ifdef ZION_DEBUG
   for (auto &module_pair : symbol_imports) {
     for (auto &pair_ids : module_pair.second) {
-      debug_above(3,
-                  log("import: %s: %s -> %s", module_pair.first.c_str(),
-                      pair_ids.first.c_str(), join(pair_ids.second).c_str()));
+      debug_above(3, log("import: " c_module("%s") " imports from " c_module(
+                             "%s") " {%s}",
+                         module_pair.first.c_str(), pair_ids.first.c_str(),
+                         join(pair_ids.second).c_str()));
     }
   }
 #endif
 
+  if (getenv("DOT_DEPS") != nullptr) {
+    std::string filename = "zion.dot";
+    FILE *fp = fopen(filename.c_str(), "wt");
+    if (fp == nullptr) {
+      throw zion::user_error(INTERNAL_LOC(),
+                             "unable to open %s for writing DOT_DEPS",
+                             filename.c_str());
+    }
+    fprintf(fp, "digraph G {\n");
+
+    std::unordered_set<std::string> deps;
+
+    for (auto &module_pair : symbol_imports) {
+      for (auto &pair_ids : module_pair.second) {
+        for (auto symbol : pair_ids.second) {
+
+          deps.insert(string_format("\"%s\" -> \"%s\";",
+                  tld::tld(module_pair.first).c_str(),
+                  tld::mktld(module_pair.first, symbol.name).c_str()));
+          deps.insert(string_format("\"%s\" -> \"%s\";",
+                  tld::tld(module_pair.first).c_str(),
+                  tld::tld(pair_ids.first).c_str()));
+          deps.insert(string_format("\"%s\" -> \"%s\";",
+                  tld::mktld(module_pair.first, symbol.name).c_str(),
+                  tld::mktld(pair_ids.first, symbol.name).c_str()));
+        }
+      }
+    }
+
+    for (auto dep : deps) {
+      fprintf(fp, "  %s\n", dep.c_str());
+    }
+    fprintf(fp, "}\n");
+    fclose(fp);
+  }
+
   for (auto &module_pair : symbol_exports) {
     for (auto &id_pair : module_pair.second) {
       debug_above(2, log("export: %s: %s -> %s", module_pair.first.c_str(),
                          id_pair.first.str().c_str(),
                          id_pair.second.str().c_str()));
       if (id_pair.second.name != id_pair.first.name) {
         /* this export actually leads back to something else */
-        if (graph.count(id_pair.first) == 1) {
+        if (graph.count(id_pair.first) != 0) {
           throw user_error(id_pair.first.location, "ambiguous export %s vs. %s",
                            id_pair.first.str().c_str(),
                            graph.at(id_pair.first).str().c_str());
@@ -53,7 +91,7 @@ RewriteImportRules solve_rewriting_imports(
     Identifier resolved_id = pair.second;
     std::set<Identifier> visited;
     std::list<Identifier> visited_list;
-    while (graph.count(resolved_id) == 1) {
+    while (graph.count(resolved_id) != 0) {
       visited.insert(resolved_id);
       visited_list.push_back(resolved_id);
 
@@ -69,6 +107,7 @@ RewriteImportRules solve_rewriting_imports(
         throw error;
       }
     }
+
     /* rewrite the graph as we go to avoid wasting time for future traversals */
     for (auto &id : visited_list) {
       graph[id] = resolved_id;
@@ -105,8 +144,10 @@ RewriteImportRules solve_rewriting_imports(
           debug_above(3, log("couldn't find %s in legal_exports. found %s",
                              fqn.c_str(), join(legal_exports).c_str()));
           illegal_imports.push_back(
-              {Identifier{tld::mktld(source_module, symbol.name), symbol.location},
-               Identifier{tld::mktld(dest_module, symbol.name), symbol.location}});
+              {Identifier{tld::mktld(source_module, symbol.name),
+                          symbol.location},
+               Identifier{tld::mktld(dest_module, symbol.name),
+                          symbol.location}});
         }
       }
     }

src/main.cpp

@@ -351,7 +351,16 @@ tarjan::Graph build_program_graph(const std::vector<const Decl *> &decls) {
   tarjan::Graph graph;
   for (auto decl : decls) {
     const auto &name = decl->id.name;
-    graph.insert({name, get_free_vars(decl->value, {})});
+    const auto free_vars = get_free_vars(decl->value, {});
+    for (auto free_var : free_vars) {
+      if (!zion::tld::is_fqn(free_var)) {
+        throw user_error(
+            decl->id.location,
+            "found free_var \"%s\" that is not fully qualified within %s",
+            free_var.c_str(), name.c_str());
+      }
+    }
+    graph.insert({name, free_vars});
   }
   return graph;
 }
@@ -492,13 +501,13 @@ const Decl *find_overload_for_instance(std::string name,
    * impl.
    */
   for (const Decl *decl : instance->decls) {
-    assert(name == "*" || tld::is_fqn(name, true /*default_special*/));
+    assert(tld::is_fqn(name));
     if (decl->id.name == name) {
       return decl;
     }
   }
   for (const Decl *decl : type_class->default_decls) {
-    assert(tld::is_fqn(name, true /*default_special*/));
+    assert(tld::is_fqn(name));
     if (decl->id.name == name) {
       return decl;
     }

src/parse_state.cpp

@@ -82,19 +82,19 @@ Identifier ParseState::identifier_and_advance(bool map_id) {
 }
 
 Identifier ParseState::id_mapped(Identifier id) {
-  if (tld::is_fqn(id.name, true /*default_special*/)) {
+  if (tld::is_fqn(id.name)) {
     /* this has already been mapped */
     return id;
   }
   auto iter = term_map.find(id.name);
   if (iter != term_map.end()) {
     return Identifier{iter->second, id.location};
   } else {
-    if (id.name == "offset") {
-      for (auto pair : term_map) {
-        log("term_map = %s -> %s", pair.first.c_str(), pair.second.c_str());
-      }
-    }
+    /* if (id.name == "offset") { */
+    /*   for (auto pair : term_map) { */
+    /*     log("term_map = %s -> %s", pair.first.c_str(), pair.second.c_str()); */
+    /*   } */
+    /* } */
     return id;
   }
 }
@@ -114,7 +114,7 @@ void ParseState::add_term_map(Location location,
                               std::string key,
                               std::string value,
                               bool allow_override) {
-  // log("adding %s to term map => %s", key.c_str(), value.c_str());
+  debug_above(3, log("adding %s to term map => %s", key.c_str(), value.c_str()));
   if (!allow_override && in(key, term_map)) {
     throw user_error(location, "symbol %s imported twice", key.c_str())
         .add_info(location, "%s was already mapped to %s", key.c_str(),