release: v0.1.0 "Berlin"

Generics, standard repositories, and query provider-binding.

- lang: generic interfaces/classes via monomorphization, with default-method
  materialization so a class inherits (and can override) interface defaults
- std/data: Repository / CrudRepository — implement getProvider() + source(),
  inherit findAll / findById / save / delete / deleteById and entity<->model
  conversion as defaults
- query: .using(provider) binds a provider to any query so terminals run
  against it across method boundaries; .first() terminal; QueryProvider.name()
  enables `where`-based provider selection
- codegen: `x as Json` now works on primitive values
- examples/data: repository, sqlite-backed, and provider-where demos
- editors: tree-sitter grammar handles generic declarations and `as` casts;
  bumped vscode / zed / tree-sitter extension versions

Author: code-by-sia

compiler/impl/codegen/codecs.xi

@@ -118,6 +118,10 @@ mapper jsonOfPayload(prog: Program, xtype: String, code: String) -> String {
              + " for (xc_integer_t __pi = 0; __pi < (xc_integer_t)__pv.len; __pi++)"
              + " xstd_json_push(__pa, " + encE + "); __pa; })"
     }
+    // scalar: a primitive (Integer/String/Number/Bool/Json) encodes directly, a
+    // compound routes through its derived codec — jsonEncodeExpr handles both.
+    let enc = jsonEncodeExpr(prog, xtype.xnameToCtype(), code)
+    if string_len(enc) > 0 { return enc }
     return "xc_tojson_" + xtype + "(" + code + ")"
 }
 

compiler/impl/codegen/generics.xi

@@ -226,8 +226,40 @@ predicate Program.isGenericIfaceName(name: String) {
     return false
 }
 
+predicate matHasMethod(ms: MethodSpec[], name: String) {
+    let i = 0
+    while i < methodSpecLen(ms) { if methodSpecGet(ms, i).name == name { return true }  i = i + 1 }
+    return false
+}
+
+mapper ifaceByName(acc: IfaceSpec[], name: String) -> IfaceSpec {
+    let i = 0
+    while i < ifaceSpecLen(acc) {
+        if ifaceSpecGet(acc, i).name == name { return ifaceSpecGet(acc, i) }
+        i = i + 1
+    }
+    return IfaceSpec { name: "", extendsNames: [], methList: [], typeParams: [], extendsArgs: [] }
+}
+
+// A concrete interface method stripped of its default body — so the class that
+// implements it supplies the code (materialized, see below) and no shared
+// `_default_impl` is emitted for a body that may reach into `this`.
+mapper stripBody(ms: MethodSpec) -> MethodSpec {
+    return MethodSpec {
+        isAsync: ms.isAsync, kind: ms.kind, name: ms.name, params: ms.params,
+        retCtype: ms.retCtype, bodyTokens: [], topic: ms.topic,
+        hasWhere: ms.hasWhere, whereTokens: [], fnDeps: ms.fnDeps
+    }
+}
+
 // The whole pass: rewrite classes' generic implements to concrete names and
 // return a Program whose ifaces = (non-generic originals) + (synthesized).
+//
+// Generic interface defaults are **materialized** into each implementing class:
+// an un-overridden default method is copied (already type-substituted) into the
+// class's own methList, so its body dispatches to sibling methods on `this`
+// (getProvider / source / findAll ...) through normal class-method codegen. The
+// synthesized interface then carries the method as abstract.
 mapper monomorphize(prog: Program) -> Program {
     let synth: IfaceSpec[] = []
     let newClasses: ClassSpec[] = []
@@ -236,6 +268,7 @@ mapper monomorphize(prog: Program) -> Program {
     while ci < classSpecLen(prog.classes) {
         let cs = classSpecGet(prog.classes, ci)
         let newImpl: String[] = []
+        let matMeths: MethodSpec[] = []     // default methods materialized into this class
         let ii = 0
         while ii < stringArrLen(cs.implNames) {
             let ifn = stringArrGet(cs.implNames, ii)
@@ -252,19 +285,39 @@ mapper monomorphize(prog: Program) -> Program {
                     k = k + 1
                 }
                 synth = synthIface(prog, ifn, arg, synth)
+                // materialize un-overridden defaults from the top concrete interface
+                // (its methList already flattens every extended interface's methods)
+                let top = ifaceByName(synth, monoName(ifn, arg))
+                let tm = 0
+                while tm < methodSpecLen(top.methList) {
+                    let m = methodSpecGet(top.methList, tm)
+                    if tokenArrLen(m.bodyTokens) > 0 and countMethodName(cs, m.name) == 0
+                       and not matHasMethod(matMeths, m.name) {
+                        matMeths = appendMethodSpec(matMeths, m)
+                    }
+                    tm = tm + 1
+                }
             } else {
                 newImpl = appendString(newImpl, ifn)
             }
             ii = ii + 1
         }
+        let finalMeths = cs.methList
+        let mm = 0
+        while mm < methodSpecLen(matMeths) {
+            finalMeths = appendMethodSpec(finalMeths, methodSpecGet(matMeths, mm))
+            mm = mm + 1
+        }
         newClasses = appendClassSpec(newClasses, ClassSpec {
-            name: cs.name, implNames: newImpl, depList: cs.depList, methList: cs.methList,
+            name: cs.name, implNames: newImpl, depList: cs.depList, methList: finalMeths,
             stateFields: cs.stateFields, stateInit: cs.stateInit, implArgs: cs.implArgs
         })
         ci = ci + 1
     }
 
-    // final ifaces: keep non-generic originals, drop templates, add synthesized
+    // final ifaces: keep non-generic originals, drop templates, add synthesized.
+    // Synthesized interface methods are stripped to abstract — every implementing
+    // class carries the body (its own override or a materialized default).
     let newIfaces: IfaceSpec[] = []
     let fi = 0
     while fi < ifaceSpecLen(prog.ifaces) {
@@ -274,7 +327,17 @@ mapper monomorphize(prog: Program) -> Program {
     }
     let si = 0
     while si < ifaceSpecLen(synth) {
-        newIfaces = appendIfaceSpec(newIfaces, ifaceSpecGet(synth, si))
+        let sIf = ifaceSpecGet(synth, si)
+        let absMeths: MethodSpec[] = []
+        let am = 0
+        while am < methodSpecLen(sIf.methList) {
+            absMeths = appendMethodSpec(absMeths, stripBody(methodSpecGet(sIf.methList, am)))
+            am = am + 1
+        }
+        newIfaces = appendIfaceSpec(newIfaces, IfaceSpec {
+            name: sIf.name, extendsNames: sIf.extendsNames, methList: absMeths,
+            typeParams: [], extendsArgs: []
+        })
         si = si + 1
     }
 

compiler/impl/codegen/queryreify.xi

@@ -508,47 +508,61 @@ mapper genQueryStage(toks: Token[], p: Integer, recv: String, typ: String, ctx:
         return ExprRes { code: qStageAppendC(recv, stage, u), pos: q, xtyp: pfx + "qpair:" + elem + ":" + relem, owned: false }
     }
 
-    if fld == "collect" {
-        if elem.startsWith2("qpair:") or elem.startsWith2("qgroup:") {
-            diag_error(line, "xi-query: project joined/grouped rows with .map { ... } before .collect")
-        }
+    if fld == "using" {
+        // bind a provider to the query so the terminals run against it, no DI.
+        // Store the fat-pointer halves as opaque handles (see QueryPlan).
         let ae = genExpr(toks, p + 3, ctx)
         let q = ae.pos
         if toks.kindAt(q) == 101 { q = q + 1 }
-        let ct = elem.xnameToCtype()
-        let dec = jsonDecodeExpr(ctx.prog, ct, "xstd_json_at(__qr" + u + ", __qi" + u + ")")
-        if string_len(dec) == 0 {
-            diag_error(line, "xi-query: can't decode rows into element type '" + elem + "'")
-        }
-        let code = "({ xc_QueryProvider_t __qv" + u + " = " + ae.code + "; "
-                 + "xc_Json_t __qr" + u + " = __qv" + u + ".vtable->run(__qv" + u + ".self, " + recv + "); "
-                 + "xc_List_t __ql" + u + " = xstd_list_new(sizeof(" + ct + ")); "
-                 + "for (xc_integer_t __qi" + u + " = 0; __qi" + u + " < xstd_json_length(__qr" + u + "); __qi" + u + "++) { "
-                 + ct + " __qe" + u + " = " + dec + "; "
-                 + "xstd_list_push(__ql" + u + ", (" + ct + "[]){ __qe" + u + " }); } __ql" + u + "; })"
-        return ExprRes { code: code, pos: q, xtyp: "List_" + elem, owned: false }
+        let code = "({ xc_QueryPlan_t __qp" + u + " = " + recv + "; xc_QueryProvider_t __qpp" + u + " = " + ae.code + "; "
+                 + "__qp" + u + ".providerSelf = __qpp" + u + ".self; __qp" + u + ".providerVtable = (void*)__qpp" + u + ".vtable; __qp" + u + "; })"
+        return ExprRes { code: code, pos: q, xtyp: typ, owned: false }
     }
 
-    if fld == "toList" {
-        // run the query with no explicit provider. A list-rooted query uses an
-        // ephemeral MemorySource over its inline rows; a source-rooted query uses
-        // the module's bound QueryProvider (DI) — this is what lets a repository's
-        // findAll().filter{...}.toList() work.
+    if fld == "collect" or fld == "toList" or fld == "first" {
+        // Terminals. `collect(p)` runs against the explicit provider `p`.
+        // `collect()` / `toList()` / `first()` run against the query's bound
+        // provider (set by `.using`); with none bound they fall back to the
+        // module's DI-resolved provider (source-rooted) or an ephemeral
+        // MemorySource (list-rooted). `first` yields the first row as `T?`.
         if elem.startsWith2("qpair:") or elem.startsWith2("qgroup:") {
-            diag_error(line, "xi-query: project joined/grouped rows with .map { ... } before .toList")
+            diag_error(line, "xi-query: project joined/grouped rows with .map { ... } before ." + fld)
         }
-        let q = p + 2
-        if toks.kindAt(q) == 100 { q = q + 1  if toks.kindAt(q) == 101 { q = q + 1 } }   // ()
         let ct = elem.xnameToCtype()
+        // an explicit provider arg (collect(p)) — otherwise use the bound/fallback
+        let hasArg = false
+        let argCode = ""
+        let q = p + 2
+        if toks.kindAt(q) == 100 {
+            q = q + 1
+            if toks.kindAt(q) != 101 {
+                let ae = genExpr(toks, q, ctx)
+                hasArg = true  argCode = ae.code  q = ae.pos
+            }
+            if toks.kindAt(q) == 101 { q = q + 1 }
+        }
+        let fallback = "xc_resolve_QueryProvider()"
+        if local { fallback = "xc_MemorySource_as_QueryProvider(xc_new_MemorySource())" }
+        let bound = "(xc_QueryProvider_t){ .self = __qp" + u + ".providerSelf, .vtable = (const xc_QueryProvider_vtable_t*)__qp" + u + ".providerVtable }"
+        let pick = "(__qp" + u + ".providerVtable ? " + bound + " : (" + fallback + "))"
+        if hasArg { pick = argCode }
+        let head = "({ xc_QueryPlan_t __qp" + u + " = " + recv + "; "
+                 + "xc_QueryProvider_t __qv" + u + " = " + pick + "; "
+                 + "xc_Json_t __qr" + u + " = __qv" + u + ".vtable->run(__qv" + u + ".self, __qp" + u + "); "
+        if fld == "first" {
+            let dec0 = jsonDecodeExpr(ctx.prog, ct, "xstd_json_at(__qr" + u + ", 0)")
+            if string_len(dec0) == 0 {
+                diag_error(line, "xi-query: can't decode rows into element type '" + elem + "'")
+            }
+            let code = head + "xc_opt_" + elem + "_t __qo" + u + "; __qo" + u + ".has_value = 0; "
+                     + "if (xstd_json_length(__qr" + u + ") > 0) { __qo" + u + ".has_value = 1; __qo" + u + ".value = " + dec0 + "; } __qo" + u + "; })"
+            return ExprRes { code: code, pos: q, xtyp: "opt_" + elem, owned: false }
+        }
         let dec = jsonDecodeExpr(ctx.prog, ct, "xstd_json_at(__qr" + u + ", __qi" + u + ")")
         if string_len(dec) == 0 {
             diag_error(line, "xi-query: can't decode rows into element type '" + elem + "'")
         }
-        let providerC = "xc_resolve_QueryProvider()"
-        if local { providerC = "xc_MemorySource_as_QueryProvider(xc_new_MemorySource())" }
-        let code = "({ xc_QueryProvider_t __qv" + u + " = " + providerC + "; "
-                 + "xc_Json_t __qr" + u + " = __qv" + u + ".vtable->run(__qv" + u + ".self, " + recv + "); "
-                 + "xc_List_t __ql" + u + " = xstd_list_new(sizeof(" + ct + ")); "
+        let code = head + "xc_List_t __ql" + u + " = xstd_list_new(sizeof(" + ct + ")); "
                  + "for (xc_integer_t __qi" + u + " = 0; __qi" + u + " < xstd_json_length(__qr" + u + "); __qi" + u + "++) { "
                  + ct + " __qe" + u + " = " + dec + "; "
                  + "xstd_list_push(__ql" + u + ", (" + ct + "[]){ __qe" + u + " }); } __ql" + u + "; })"
@@ -560,6 +574,6 @@ mapper genQueryStage(toks: Token[], p: Integer, recv: String, typ: String, ctx:
         return ExprRes { code: recv, pos: p + 2, xtyp: "QueryPlan", owned: false }
     }
 
-    diag_error(line, "xi-query: unknown stage '." + fld + "' — supported: filter, map, sortedBy, sortedByDescending, take, drop, concat, join, groupBy, collect, toList, plan")
+    diag_error(line, "xi-query: unknown stage '." + fld + "' — supported: filter, map, sortedBy, sortedByDescending, take, drop, concat, join, groupBy, using, collect, toList, first, plan")
     return ExprRes { code: recv, pos: p + 2, xtyp: typ, owned: false }
 }

compiler/impl/driver/driver.xi

@@ -532,7 +532,10 @@ producer packLibrary(srcPath: String) -> Integer {
 }
 
 // The toolchain version (kept in sync with the xi tool); printed by `xc version`.
-mapper xcVersion() -> String { return "0.0.99" }
+mapper xcVersion() -> String { return "0.1.0" }
+
+// The release codename, shown alongside the version.
+mapper xcCodename() -> String { return "Berlin" }
 
 // The value of a `--target <t>` / `--target=<t>` flag anywhere in args, or "".
 mapper argTarget(args: String[]) -> String {

compiler/impl/driver/xc_compiler.xi

@@ -126,7 +126,7 @@ class XcCompiler implements Compiler {
         }
         let srcPath = cliSource(args)
         if srcPath == "version" or srcPath == "--version" or srcPath == "-v" {
-            system.stdout.writeln("xc " + xcVersion())
+            system.stdout.writeln("xc " + xcVersion() + " \"" + xcCodename() + "\"")
             return 0
         }
         if srcPath == "--all" { return buildAll() }

compiler/loadtest.xi

@@ -187,7 +187,7 @@ module LoadTest {
     id           = "loadtest"
     name         = "Xi Load Tester"
     description  = "Load/perf testing for Xi projects: compile-stress, run-bench, and HTTP load."
-    version      = "0.0.99"
+    version      = "0.1.0"
     license      = "Apache 2.0"
     includes     = []
     excludes     = []

compiler/repl/runner.xi

@@ -88,7 +88,10 @@ mapper buildProgram(decls: String, stmts: String) -> String {
 }
 
 // The toolchain version. Bump this when cutting a release (matches the tag).
-mapper xiVersion() -> String { return "0.0.99" }
+mapper xiVersion() -> String { return "0.1.0" }
+
+// The release codename, shown alongside the version.
+mapper xiCodename() -> String { return "Berlin" }
 
 // Directory part of a path (everything before the last '/'); "." if none.
 mapper dirOf(path: String) -> String {

compiler/repl/xi_repl.xi

@@ -7,7 +7,7 @@ class XiRepl implements Repl {
         if args.len >= 2 {
             let sub = args.data[1]
             if sub == "version" or sub == "--version" or sub == "-v" {
-                system.stdout.writeln("xi " + xiVersion())
+                system.stdout.writeln("xi " + xiVersion() + " \"" + xiCodename() + "\"")
                 return 0
             }
             if sub == "update" {

compiler/test.xi

@@ -14,7 +14,7 @@ module Test {
     id           = "xt"
     name         = "Xi Test Runner"
     description  = "Compiles and runs *_test.xi files in test mode, reporting pass/fail."
-    version      = "0.0.99"
+    version      = "0.1.0"
     license      = "Apache 2.0"
     includes     = []
     excludes     = []

compiler/xc.xi

@@ -92,7 +92,7 @@ module Compile {
     id           = "xc"
     name         = "Xi Compiler"
     description  = "The Xi language compiler — Xi source to C99 to native binaries."
-    version      = "0.0.99"
+    version      = "0.1.0"
     license      = "Apache 2.0"
     includes     = []
     excludes     = []