Fix external array definitions:

* accept array definitions without length in interface files
* reject `elemsof` and `sizeof` on arrays of unknown length
* simplify external array definitions in C generator, remove array decay
* expose actual array lengths as numbers, including implied array lengths
  and incremental array lengths
* control name mangling according to library source language:
  c2/native language libraries use module name prefix, others use c name
* fix test/interface/incremental_array.c2t: fix external array definition
* fix test/interface/public_by_array_expr.c2t: fix external array definition
* fix test/interface/muti_dimensional_array.c2t: `Row` and `Columns` definitions
  were reversed, 2D external array definition in C was incorrect
* add tests for arrays with unspecified size

Author: chqrlie

analyser/module_analyser.c2

@@ -563,7 +563,7 @@ fn void Analyser.analyseGlobalVarDecl(Analyser* ma, VarDecl* v) {
                 return;
             }
         } else {
-            if (!init_expr) {
+            if (!init_expr && !d.isExternal()) {
                 ma.error(d.getLoc(), "array-type variable '%s' needs an explicit size or an initializer", d.getFullName());
                 return;
             }

analyser/module_analyser_builtin.c2

@@ -59,6 +59,13 @@ fn QualType Analyser.analyseSizeof(Analyser* ma, BuiltinExpr* e) {
         if (qt.isInvalid()) return QualType_Invalid;
 
         // TODO extract to function
+        if (qt.isArray()) {
+            const ArrayType* at = qt.getArrayTypeOrNil();
+            if (at && !at.hasSize()) {
+                ma.error(inner.getLoc(), "sizeof cannot be used on arrays of unknown length");
+                return QualType_Invalid;
+            }
+        }
         if (qt.isStruct()) {
             StructType* st = qt.getStructType();
             const StructTypeDecl* std = st.getDecl();
@@ -95,6 +102,10 @@ fn QualType Analyser.analyseElemsof(Analyser* ma, BuiltinExpr* b) {
 
     const ArrayType* at = qt.getArrayTypeOrNil();
     if (at) {
+        if (!at.hasSize()) {
+            ma.error(inner.getLoc(), "elemsof cannot be used on arrays of unknown length");
+            return QualType_Invalid;
+        }
         b.setUValue(at.getSize());
         return builtins[BuiltinKind.UInt32];
     }

ast/builtin_type.c2

@@ -248,7 +248,7 @@ fn bool BuiltinType.isVoid(const BuiltinType* b) {
     return b.base.builtinTypeBits.kind == BuiltinKind.Void;
 }
 
-fn const char* BuiltinType.kind2str(const BuiltinType* b) {
+public fn const char* BuiltinType.kind2str(const BuiltinType* b) {
     return builtinType_names[b.getKind()];
 }
 

ast/expr.c2

@@ -548,7 +548,7 @@ public fn void Expr.printLiteral(const Expr* e, string_buffer.Buf* out) {
         IdentifierExpr.printLiteral((IdentifierExpr*)e, out);
         return;
     case Type:
-        TypeExpr.printLiteral((TypeExpr*)e, out, false);
+        TypeExpr.printLiteral((TypeExpr*)e, out);
         return;
     case Call:
         CallExpr.printLiteral((CallExpr*)e, out);

ast/module.c2

@@ -29,6 +29,7 @@ public type Module struct @(opaque) {
     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
     ModuleType* mt;
@@ -48,6 +49,7 @@ public fn Module* Module.create(ast_context.Context* c, u32 name_idx, bool is_ex
     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;
@@ -76,6 +78,9 @@ 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; }
+public fn bool Module.isForeign(const Module* m) { return m.is_foreign; }
+
 public fn void Module.setLoaded(Module* m) { m.is_loaded = true; }
 public fn bool Module.isLoaded(const Module* m) { return m.is_loaded; }
 

ast/type_expr.c2

@@ -74,6 +74,6 @@ fn void TypeExpr.print(const TypeExpr* e, string_buffer.Buf* out, u32 indent) {
     out.newline();
 }
 
-fn void TypeExpr.printLiteral(const TypeExpr* e, string_buffer.Buf* out, bool decay) {
-    e.typeRef.printLiteral(out, true, decay);
+fn void TypeExpr.printLiteral(const TypeExpr* e, string_buffer.Buf* out) {
+    e.typeRef.printLiteral(out, true);
 }

ast/type_ref.c2

@@ -332,7 +332,7 @@ public fn Expr** TypeRef.getArray2(TypeRef* r, u32 idx) {
     return &arrays[idx];
 }
 
-public fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bool print_prefix, bool decay) {
+fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bool print_prefix) {
     if (r.isConst()) out.add("const ");
     if (r.isVolatile()) out.add("volatile ");
 
@@ -350,25 +350,18 @@ public fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bo
 
     for (u32 i=0; i<r.flags.num_ptrs; i++) out.add1('*');
 
-    // note: convert arrays into pointers
-    if (r.flags.incr_array) out.add("*");
+    if (r.flags.incr_array) out.add("[+]");
 
-    if (decay) {
-        // TODO: this seems incorrect: char[10][10] does not decay as char**
-        for (u32 i = 0; i < r.flags.num_arrays; i++) {
-            out.add("*");
-        }
-    } else {
-        for (u32 i = 0; i < r.flags.num_arrays; i++) {
-            out.add1('[');
-            const Expr* a = r.getArray(i);
-            // note: a can be nil, when[]
-            if (a) a.printLiteral(out);
-            out.add1(']');
-        }
+    for (u32 i = 0; i < r.flags.num_arrays; i++) {
+        out.add1('[');
+        const Expr* a = r.getArray(i);
+        // note: a can be nil, when[]
+        if (a) a.printLiteral(out);
+        out.add1(']');
     }
 }
 
+#if 0
 public type ExprPrinter fn void(void* arg, const Expr* e, string_buffer.Buf* out);
 
 // Prints arrays as arrays
@@ -390,16 +383,22 @@ public fn void TypeRef.printLiteral2(const TypeRef* r, string_buffer.Buf* out, b
 
     for (u32 i=0; i<r.flags.num_ptrs; i++) out.add1('*');
 
-    if (r.flags.incr_array) out.add("*");
+    if (r.flags.incr_array) out.add("[+]");
 
     for (u32 i=0; i<r.flags.num_arrays; i++) {
         out.add1('[');
         const Expr* a = r.getArray(i);
         // note: a can be nil, when[]
-        if (a) print_expr(arg, a, out);
+        if (a) {
+            if (print_expr)
+                print_expr(arg, a, out);
+            else
+                a.printLiteral(out);
+        }
         out.add1(']');
     }
 }
+#endif
 
 fn void TypeRef.print(const TypeRef* r, string_buffer.Buf* out, bool filled) {
     // eg. const test.Foo*[10]

common/component.c2

@@ -63,6 +63,7 @@ public type Component struct @(opaque) {
     u32 linkname;   // into auxPool
     Kind kind;
     bool is_direct; // only for external, if used directly (otherwise sub-dep)
+    bool is_foreign;        // only for external
     bool available_static;  // only for external
     bool available_dynamic; // only for external
 
@@ -116,6 +117,14 @@ public fn const char* Component.getPath(const Component* c) {
     return c.auxPool.idx2str(c.dirname_idx);
 }
 
+public fn void Component.setForeign(Component* c, bool is_foreign) {
+    c.is_foreign = is_foreign;
+}
+
+public fn bool Component.getForeign(const Component* c) {
+    return c.is_foreign;
+}
+
 public fn void Component.setLinkName(Component* c, const char* name) {
     c.linkname = c.auxPool.addStr(name, false);
 }

compiler/compiler_libs.c2

@@ -113,7 +113,9 @@ fn void Compiler.open_lib(Compiler* c, Component* comp) {
     for (u32 i=0; i<mods.length(); i++) {
         u32 mod_name = mods.get_idx(i);
         ast.Module* m = comp.getOrAddModule(mod_name);
-        if (!m) {
+        if (m) {
+            m.setForeign(comp.getForeign());
+        } else {
             m = c.allmodules.find(mod_name);
             Component* other = c.find_component(m);
             assert(other);

compiler/manifest.c2

@@ -24,6 +24,7 @@ import yaml;
 
 import stdlib;
 import stdio local;
+import string local;
 
 fn const yaml.Node* get_checked(yaml.Parser* parser, const char* path) {
     const yaml.Node* node = parser.findNode(path);
@@ -70,6 +71,10 @@ fn bool getYamlInfo(yaml.Parser* parser,
 
     comp.setKind(kind_static, kind_dynamic);
 
+    const char* language = parser.getScalarValue("info.language");
+    // component is foreign unless language is specified as c2 or native
+    comp.setForeign(!language || (strcasecmp(language, "c2") && strcasecmp(language, "native")));
+
     iter = parser.getNodeChildIter(modulesNode);
     while (!iter.done()) {
         // Note: module names need to be put in normal pool, NOT auxPool!