source_libs: implement source libs

* see documentation on how to use
* added test_source_lib to libs for testing
* fix manifest.yaml generation for multiple deps, c2 dep
* cgen: only use linkname for static/dynamic libs
* extract generation phase from compiler.c2 to own file
* extract analysis phase from compiler.c2 to own file

Author: bvdberg

analyser/module_analyser.c2

@@ -273,7 +273,7 @@ fn void Analyser.handleImport(void* arg, ast.ImportDecl* id) {
     if (!d.isUsedPublic()) return;
 
     Module* dest = id.getDest();
-    if (dest.isExternal() || dest.isInternal()) return;
+    if (dest.isExternal()) return;
     if (!dest.isExported()) {
         ma.error(d.getLoc(), "exported module '%s' publicly uses non-exported module '%s'", ma.mod.getName(), dest.getName());
     }

analyser/module_analyser_member.c2

@@ -99,7 +99,7 @@ fn QualType Analyser.analyseMemberExpr(Analyser* ma, Expr** e_ptr, u32 side) {
                 if (is_ptr && ck != CallKind.Invalid) is_const = false;
                 m.setConstBase(is_const);
                 if (is_const && ck == CallKind.Invalid) baseType.setConst();
-                // TODO BBB set ck same was as Enum below
+                // TODO set ck same was as Enum below
 
                 // no need to update valtype
                 break;
@@ -203,7 +203,6 @@ fn QualType Analyser.analyseMemberExpr(Analyser* ma, Expr** e_ptr, u32 side) {
 
         if (ck == CallKind.Invalid && d.isFunction()) ck = CallKind.Normal;
         // NOTE: set SF/SSF based on member: Foo.next will be SSF, f.next SF
-        // TODO BBB
         if (ck == CallKind.TypeFunc) m.setIsTypeFunc();
         if (ck == CallKind.StaticTypeFunc) m.setIsStaticTypeFunc();
         // Note: dont call setValType here, done in setExprFlags

ast/ast.c2

@@ -276,6 +276,7 @@ public fn void AST.info(const AST* a, string_buffer.Buf* out) {
 */
 
 fn void AST.print(const AST* a, string_buffer.Buf* out, bool show_funcs) {
+    out.color(col_Normal);
     out.print("---- AST %s ----\n", a.getFilename());
 
     ImportDecl** imports = a.imports.getDecls();

ast/module.c2

@@ -25,13 +25,12 @@ import string;
 
 public type Module struct @(opaque) {
     u32 name_idx;
-    bool is_used;
-    bool is_external;
-    bool is_internal; // currently only for c2 module
-    bool is_direct; // otherwise indirectly loaded via library.
-    bool is_foreign; // module identifiers are not mangled
-    bool is_exported;
-    bool is_loaded; // the file(s) parsed. For external libs
+    u32 is_used : 1;
+    u32 is_external : 1;   // if not in the main component
+    u32 is_foreign : 1;    // module identifiers are not mangled
+    u32 is_exported : 1;   // if exported in library interface
+    u32 is_loaded : 1;     // the file(s) parsed. For external dynamic/static libs
+    u32 is_private : 1;    // for source-libs
     ModuleType* mt;
 
     ast.AST** files;
@@ -41,17 +40,15 @@ public type Module struct @(opaque) {
     SymbolTable symbols;
     InstanceTable instances;
 }
-static_assert(88, sizeof(Module));
+static_assert(80, sizeof(Module));
 
 // Note: name must be allocated in target StringPool
-public fn Module* Module.create(ast_context.Context* c, u32 name_idx, bool is_external, bool is_direct) {
+public fn Module* Module.create(ast_context.Context* c, u32 name_idx, bool is_external) {
     Module* m = stdlib.calloc(1, sizeof(Module));
     m.mt = ModuleType.create(c, m);
     m.name_idx = name_idx;
     m.is_external = is_external;
     m.is_foreign = is_external;    // default for external modules
-    m.is_internal = false;
-    m.is_direct = is_direct;
     m.is_loaded = false;
     m.resizeFiles(1);
     m.symbols.init(16);
@@ -72,10 +69,6 @@ public fn void Module.free(Module* m) {
 public fn void Module.setUsed(Module* m) { m.is_used = true; }
 public fn bool Module.isUsed(const Module* m) { return m.is_used; }
 
-// TODO use use a keyword or an attribute for this
-public fn void Module.setInternal(Module* m) @(unused) { m.is_internal = true; }
-public fn bool Module.isInternal(const Module* m) { return m.is_internal; }
-
 public fn bool Module.isExternal(const Module* m) { return m.is_external; }
 
 public fn void Module.setForeign(Module* m, bool is_foreign) { m.is_foreign = is_foreign; }
@@ -90,10 +83,10 @@ public fn void Module.setExported(Module* m) {
         m.files[i].setExported();
     }
 }
-
 public fn bool Module.isExported(const Module* m) { return m.is_exported; }
 
-public fn bool Module.isDirect(const Module* m) { return m.is_direct; }
+public fn void Module.setPrivate(Module* m, bool is_private) { m.is_private = is_private; }
+public fn bool Module.isPrivate(const Module* m) { return m.is_private; }
 
 public fn const SymbolTable* Module.getSymbols(const Module* m) { return &m.symbols; }
 
@@ -229,32 +222,9 @@ public fn ast.FunctionDecl* Module.getInstance(const Module* m, ast.FunctionDecl
     return m.instances.get(fd, idx);
 }
 
-/*
-public type TemplateVisitor fn void (void* arg, FunctionDecl* fd, u32 idx);
-
-public fn void Module.visitInstances(const Module* m, ast.FunctionDecl* fd, TemplateVisitor visitor, void* arg) {
-    m.instances.visit(fd, visitor, arg);
-}
-*/
-
-/*
-public fn void Module.info(const Module* m, string_buffer.Buf* out) {
-    out.print("  module %s\n", idx2name(m.name_idx));
-    for (u32 i=0; i<m.num_files; i++) {
-        m.files[i].info(out);
-    }
-#if 0
-    out.print("    Symbol: (%u)\n", m.num_symbols);
-    for (u32 i=0; i<m.num_symbols; i++) {
-        out.print("      %s\n", idx2name(m.symbols[i]));
-    }
-#endif
-}
-*/
-
 public fn void Module.print(const Module* m, string_buffer.Buf* out, bool show_funcs) {
     out.color(color.Normal);
-    out.print("------ module %s (used %d, exported %d) ------\n", idx2name(m.name_idx), m.is_used, m.is_exported);
+    out.print("------ module %s (used %d, exported %d, private %d) ------\n", idx2name(m.name_idx), m.is_used, m.is_exported, m.is_private);
     for (u32 i=0; i<m.num_files; i++) {
         m.files[i].print(out, show_funcs);
     }

common/build_target.c2

@@ -15,7 +15,7 @@
 
 module build_target;
 
-import library_list;
+import file_list local;
 import src_loc local;
 import string_list;
 import string_pool;
@@ -35,6 +35,7 @@ public type Kind enum u8 {
     Executable,
     StaticLibrary,
     DynamicLibrary,
+    SourceLibrary,
 }
 
 public fn bool has_dynamic(Kind k) {
@@ -47,6 +48,8 @@ public fn bool has_dynamic(Kind k) {
         return false;
     case DynamicLibrary:
         return true;
+    case SourceLibrary:
+        return false;
     }
     return false;
 }
@@ -94,11 +97,6 @@ public fn void PluginList.add(PluginList* l, u32 name, u32 options, SrcLoc loc)
     l.count++;
 }
 
-public type File struct {
-    u32 name;       // index into auxPool
-    SrcLoc loc;
-}
-
 public type Target struct @(opaque) {
     u32 name_idx;       // index into auxPool
     SrcLoc loc;
@@ -112,17 +110,12 @@ public type Target struct @(opaque) {
     bool backend_fast;
 
     string_list.List features;
-    library_list.List libs;
+    List libs;
     string_list.List exports;
     PluginList plugins;
 
-    File* files;
-    u32 num_files;
-    u32 max_files;
-
-    File* asm_files;
-    u32 asm_file_count;
-    u32 asm_file_max;
+    FileList files;
+    FileList asm_files;
 }
 
 public fn Target* create(u32 name_idx, SrcLoc loc, Kind kind, string_pool.Pool* pool) {
@@ -132,13 +125,11 @@ public fn Target* create(u32 name_idx, SrcLoc loc, Kind kind, string_pool.Pool*
     // remove this once the bootstrap handles improved flow analysis
     t.warnings.no_unreachable_code = true;
     t.kind = kind;
-    t.max_files = 8;
     t.features.init(pool);
     t.libs.init();
     t.exports.init(pool);
-    t.files = stdlib.malloc(t.max_files * sizeof(File));
-    t.asm_file_max = 4;
-    t.asm_files = stdlib.malloc(t.asm_file_max * sizeof(File));
+    t.files.init(8);
+    t.asm_files.init(0);
     return t;
 }
 
@@ -147,8 +138,8 @@ public fn void Target.free(Target* t) {
     t.plugins.free();
     t.libs.free();
     t.features.free();
-    stdlib.free(t.files);
-    stdlib.free(t.asm_files);
+    t.asm_files.free();
+    t.files.free();
     stdlib.free(t);
 }
 
@@ -158,9 +149,9 @@ public fn void Target.setNameIdx(Target* t, u32 name_idx) {
     t.name_idx = name_idx;
 }
 
-public fn u32 Target.numFiles(const Target* t) { return t.num_files; }
+public fn u32 Target.numFiles(const Target* t) { return t.files.getCount(); }
 
-public fn u32 Target.numAsmFiles(const Target* t) { return t.asm_file_count; }
+public fn u32 Target.numAsmFiles(const Target* t) { return t.asm_files.getCount(); }
 
 public fn const string_list.List* Target.getFeatures(const Target* t) { return &t.features; }
 
@@ -179,16 +170,18 @@ public fn void Target.disableAsserts(Target* t) { t.disable_asserts = true; }
 
 public fn bool Target.hasAsserts(const Target* t) { return !t.disable_asserts; }
 
-public fn void Target.visitLibs(const Target* t, library_list.Visitor visitor, void* arg) {
+public type Visitor fn void (void* arg, u32 name, Kind kind);
+
+public fn void Target.visitLibs(const Target* t, Visitor visitor, void* arg) {
     t.libs.visit(visitor, arg);
 }
 
 public fn bool Target.hasLib(const Target* t, u32 lib) {
     return t.libs.contains(lib);
 }
 
-public fn void Target.addLib(Target* t, u32 lib, bool is_static) {
-    t.libs.add(lib, is_static);
+public fn void Target.addLib(Target* t, u32 lib, Kind kind) {
+    t.libs.add(lib, kind);
 }
 
 public fn void Target.disableWarnings(Target* t) {
@@ -242,57 +235,26 @@ public fn bool Target.needsMain(const Target* t) {
         return true;
     case StaticLibrary:
     case DynamicLibrary:
+    case SourceLibrary:
         break;
     }
     return false;
 }
 
 public fn bool Target.addFile(Target* t, u32 filename, SrcLoc loc) {
-    // check for duplicates
-    for (u32 i=0; i<t.num_files; i++) {
-        if (t.files[i].name == filename) return false;
-    }
-
-    if (t.num_files == t.max_files) {
-        t.max_files *= 2;
-        File* files2 = stdlib.malloc(t.max_files * sizeof(File));
-        string.memcpy(files2, t.files, t.num_files * sizeof(File));
-        stdlib.free(t.files);
-        t.files = files2;
-    }
-
-    t.files[t.num_files].name = filename;
-    t.files[t.num_files].loc = loc;
-    t.num_files++;
-    return true;
+    return t.files.add(filename, loc);
 }
 
 public fn const File* Target.getFile(const Target* t, u32 idx) {
-    return &t.files[idx];
+    return t.files.get(idx);
 }
 
 public fn bool Target.addAsmFile(Target* t, u32 filename, SrcLoc loc) {
-    // check for duplicates
-    for (u32 i=0; i<t.asm_file_count; i++) {
-        if (t.asm_files[i].name == filename) return false;
-    }
-
-    if (t.asm_file_count == t.asm_file_max) {
-        t.asm_file_max *= 2;
-        File* files2 = stdlib.malloc(t.asm_file_max * sizeof(File));
-        string.memcpy(files2, t.files, t.asm_file_count * sizeof(File));
-        stdlib.free(t.asm_files);
-        t.asm_files = files2;
-    }
-
-    t.asm_files[t.asm_file_count].name = filename;
-    t.asm_files[t.asm_file_count].loc = loc;
-    t.asm_file_count++;
-    return true;
+    return t.asm_files.add(filename, loc);
 }
 
 public fn const File* Target.getAsmFile(const Target* t, u32 idx) {
-    return &t.asm_files[idx];
+    return t.asm_files.get(idx);
 }
 
 public fn void Target.setNoLibC(Target* t) {