volaro 0.1.0-alpha.10 → 0.1.0-alpha.11

package/README.md

@@ -1,6 +1,6 @@
 # Volaro
 
-**Limited alpha** (this is `0.1.0-alpha.10`), published under both the
+**Limited alpha** (this is `0.1.0-alpha.11`), published under both the
 `latest` and `alpha` dist-tags: `npm install volaro`.
 
 Volaro is an experimental application language intended for AI authoring and

package/compiler/SOURCE_INFO.json

@@ -1,6 +1,6 @@
 {
-  "revision": "2d6678105c20c3fd24848ca7ed42b42d4d101a2b",
+  "revision": "5f9c32d19082250fc91ab3664ae6726aa2cfd0a0",
   "source": "git",
   "dirty": false,
-  "content_sha256": "792f7b32c77019c401b27beb4fe14845453312d1645499f2fa78bd7f29638719"
+  "content_sha256": "53474ecb82ebaf7ff2861f647b7796dc9c84cce73d7061ee64a65c90365a80ae"
 }

package/compiler/SOURCE_REV

@@ -1 +1 @@
-2d6678105c20c3fd24848ca7ed42b42d4d101a2b
+5f9c32d19082250fc91ab3664ae6726aa2cfd0a0

package/compiler/validator/vlcheck/ast_nodes.py

@@ -371,6 +371,7 @@ class Literal(Node):
     raw: str = ""
     interp_names: list = field(default_factory=list)
     interp_calls: list = field(default_factory=list)   # bare names called: "{len(xs)}"
+    interp_spans: list = field(default_factory=list)   # [(start, end)] of each {expr}
 
 
 @dataclass

package/compiler/validator/vlcheck/checks.py

@@ -75,6 +75,55 @@ _METHOD_ONLY = {
 }
 # Methods of a view's `load` binding, not of its value (E-LOAD-METHOD).
 _LOAD_METHODS = ("reload", "loading")
+
+# E-METHOD-UNKNOWN: the closed set of methods a Volaro *value* has. `vlbuild`
+# lowers `x.len()` and `x.format(p)` itself (emit.py `_ex_Call`) and E-LOAD-METHOD
+# owns `reload` / `loading`; any other `value.m(...)` is emitted verbatim as a
+# JavaScript method call, so a name JS strings and arrays lack (`.lower()`,
+# `.contains()`) passed the check and threw when the page ran (Testing Lab,
+# Example Demo 2.3 search brief). String and list operations are std functions
+# (spec section 13: std.str / std.list / std.map), called `f(x, ...)` or
+# `x |> f(...)`. Calls on a namespace -- `db.*` chains, `auth.*`, `route.to`,
+# `log.*`, an `api` / `service` client -- are not value methods and are judged
+# elsewhere (resolve.py R-ROUTE / E-AUTH-METHOD, the build).
+_VALUE_METHODS = {"len": 0, "format": 1}
+# Pass-throughs the build emits unchanged and that behave the same on the
+# emitted JS string / array in both targets. Not part of the std surface, but
+# the spec's own example (section 5.8, `u.email.split("@")`) and the repo's
+# reference programs use them (31 `.trim()` calls across the corpus, the
+# Chromium-verified fixtures and gate 4's form), and `slice` / `reverse` have
+# no function form yet. Accepted so existing programs keep checking clean.
+_PASS_THROUGH_METHODS = {"trim", "slice", "reverse", "join", "split"}
+# The std function to suggest, by method name. A list function (`_LIST_FNS`)
+# reads best as a pipeline (`xs |> filter(f)`), a string one as a call
+# (`lower(x)`). Includes the JavaScript / Python spellings agents carry over.
+_METHOD_FN_FORM = {
+    "lower": "lower", "upper": "upper", "trim": "trim",
+    "toLowerCase": "lower", "toUpperCase": "upper", "strip": "trim",
+    "contains": "contains", "includes": "contains",
+    "replace": "replace", "replaceAll": "replace", "replace_all": "replace",
+    "matches": "matches", "match": "matches", "test": "matches",
+    "first_char": "first_char", "split": "split", "join": "join",
+    "filter": "filter", "map": "map", "take": "take", "count": "count",
+    "sum": "sum", "sort_by": "sort_by", "group_by": "group_by",
+    "chunk": "chunk", "concat": "concat", "append": "append", "push": "append",
+    "keys": "keys", "values": "values", "get_or": "get_or",
+}
+_LIST_FNS = {"filter", "map", "take", "count", "sum", "sort_by", "group_by",
+             "chunk", "concat", "append", "join"}
+# Other common carry-overs with a Volaro spelling that is not a function call.
+_METHOD_OTHER_FIX = {
+    "length": "`{r}.len()`", "size": "`{r}.len()`",
+    "first": "`{r}[0]` (check `{r}.len() > 0` first)",
+    "at": "`{r}[i]`",
+    "get": "`{r}[i]` for a list, `get_or({r}, key, default)` for a map",
+    "to_string": "string interpolation: `\"{{{r}}}\"`",
+    "toString": "string interpolation: `\"{{{r}}}\"`",
+    "to_str": "string interpolation: `\"{{{r}}}\"`",
+}
+# Names a page-server / service body has in scope that are ambient objects,
+# not user values.
+_AMBIENT_RECEIVERS = {"session", "request"}
 # Free functions the spec shows but no emitter lowers as a bare call (not in
 # vlbuild's STD_FNS). Only an error where the build emits the call -- a view
 # or a service route; a module-level `fn` body is never emitted into either.
@@ -125,6 +174,11 @@ _STD_SUPPORTED_NAMES = {
     # `VL.std.replace`, and `server_emit.py`'s server-side `VL.std.replace`
     # shim in sync by hand, same as `matches`/`split` above.
     "replace",
+    # std.str's `contains(s, part) bool` (case-sensitive substring test).
+    # Also a `where()` predicate name (BUILTINS above); vlbuild lowers a
+    # `where(col: contains(x))` value as the predicate and every other call
+    # as `VL.std.contains`. Keep in sync with `vlbuild/emit.py`'s `STD_FNS`.
+    "contains",
 }
 
 
@@ -270,6 +324,9 @@ class Checker:
         # (module-level fn bodies)
         self._module_names: set[str] = set()
         self._emitted = True
+        # names of `fn`-typed record fields in this module: `x.on_pick(id)`
+        # calls one, which E-METHOD-UNKNOWN must not report
+        self._fn_fields: set[str] = set()
 
     # -- emit ----------------------------------------------------------
     def _d(self, code: str, sev: Severity, msg: str, node, fix: str | None = None) -> None:
@@ -294,6 +351,7 @@ class Checker:
         self.api_base(mod)
         self.imports(mod)
         self.semantic(mod)
+        self.silent_drops(mod)
         return self.diags
 
     # -- std imports: only names vlbuild actually lowers are usable --------
@@ -882,8 +940,13 @@ class Checker:
                                 "'alt:decorative' before release", node,
                                 'alt:"a clear description of what the image shows"')
 
+                # `select` / `optgroup` / `datalist` judge the elements they
+                # actually RENDER, through any `list` / `if` wrapper: a
+                # data-driven `list cats as c key:c` of `option`s is the
+                # ordinary way to build a filter, and a `div` inside that
+                # `list` is just as wrong as a direct one.
                 if node.name == "select":
-                    kids = [b for b in node.body if isinstance(b, A.Element)]
+                    kids = list(_rendered_children(node))
                     if not kids:
                         self._d("E-SELECT-EMPTY", Severity.ERROR,
                                 "'select' needs at least one 'option'", node,
@@ -900,8 +963,8 @@ class Checker:
                                 "'optgroup' needs a 'label:' -- it is the group's "
                                 "own accessible heading", node,
                                 'optgroup label:"Fruit"')
-                    for kid in node.body:
-                        if isinstance(kid, A.Element) and kid.name != "option":
+                    for kid in _rendered_children(node):
+                        if kid.name != "option":
                             self._d("E-OPTGROUP-CHILD", Severity.ERROR,
                                     "'optgroup' takes only 'option' children, "
                                     "not '%s'" % kid.name, kid)
@@ -921,8 +984,8 @@ class Checker:
                         self._d("E-DATALIST-ID", Severity.ERROR,
                                 "'datalist' needs an 'id:' so an 'input list:' "
                                 "can refer to it", node, 'datalist id:"flavors"')
-                    for kid in node.body:
-                        if isinstance(kid, A.Element) and kid.name != "option":
+                    for kid in _rendered_children(node):
+                        if kid.name != "option":
                             self._d("E-DATALIST-CHILD", Severity.ERROR,
                                     "'datalist' takes only 'option' children, "
                                     "not '%s'" % kid.name, kid)
@@ -2589,6 +2652,123 @@ class Checker:
                         "move the handler to a surrounding form",
                     )
 
+    # -- constructs the build would silently drop -----------------------
+    def silent_drops(self, mod: A.Module) -> None:
+        """Source the build used to accept and then drop, with only a `warn:`
+        line in its output (or nothing): a `derive` inside an element body,
+        a child of a `textarea`, a view-level `on unmount`, a record literal
+        field with no name, a second `service` block. Each one checked clean
+        and shipped a page that did less than its source said. `vlbuild`
+        keeps a matching `BuildError` backstop for every rule here."""
+        services = [it for it in mod.items if isinstance(it, A.ServiceDecl)]
+        for extra in services[1:]:
+            self._d("E-SERVICE-MULTIPLE", Severity.ERROR,
+                    "a module declares one `service`; this build wires only "
+                    "the first ('%s') and would drop '%s' and its routes"
+                    % (services[0].name, extra.name), extra,
+                    "move these routes into service '%s'" % services[0].name)
+
+        for it in mod.items:
+            if not isinstance(it, A.ViewDecl):
+                continue
+            for st in it.body:
+                if isinstance(st, A.OnBlock) and st.event != "mount":
+                    self._view_level_on(st, it.name)
+            self._nested_view_stmts(it.body, None, it.name)
+
+        self.record_field_names(mod)
+
+    def record_field_names(self, mod) -> None:
+        for node in _walk(mod):
+            if isinstance(node, A.RecordLit):
+                if any(k is None for k, _v in node.fields):
+                    self._d("E-RECORD-FIELD-NAME", Severity.ERROR,
+                            "every field of a record literal needs a name "
+                            "(`{name: value}`, spec 4.3) -- a positional or "
+                            "computed-key field is dropped by the build", node,
+                            "%s{field: value}" % (node.type_name or ""))
+
+    def _view_level_on(self, st: A.OnBlock, view: str) -> None:
+        if st.event in ("change", "unmount"):
+            self._d("E-LIFECYCLE-UNSUPPORTED", Severity.ERROR,
+                    "'on %s' (spec 8.5) is not implemented in this build -- "
+                    "only `on mount` runs; this block would be dropped"
+                    % st.event, st,
+                    "run the logic in the handler that changes the value, or "
+                    "in `on mount`" if st.event == "change"
+                    else "there is no unmount hook yet; a `load` is already "
+                    "cancelled on unmount")
+        elif st.event in KNOWN_EVENTS:
+            self._d("E-EVENT-TARGET", Severity.ERROR,
+                    "'on %s' at the top of view '%s' is attached to nothing, "
+                    "so it would never run -- a view-level `on` is a lifecycle "
+                    "hook (`on mount`)" % (st.event, view), st,
+                    "put it on the element that fires it:\n"
+                    "button \"Go\"\n  on %s\n    ..." % st.event)
+        else:
+            self._d("E-EVENT-UNKNOWN", Severity.ERROR,
+                    "'on %s' is not a view lifecycle hook -- the only one "
+                    "this build runs is `on mount`" % st.event, st, "on mount")
+
+    # Statements an element / `list` / `if` / `load` pending or error body
+    # renders. Everything else there was dropped by the build.
+    _RENDERED = (A.Element, A.ListBlock, A.If, A.Match, A.ChildrenMarker,
+                 A.OnBlock)
+    _STMT_WORD = {"StateDecl": "`state`", "DeriveDecl": "`derive`",
+                  "LoadDecl": "`load`", "Let": "`let`",
+                  "Assign": "an assignment",
+                  "ExprStmt": "an expression statement", "For": "`for`",
+                  "While": "`while`", "Spawn": "`spawn`", "Try": "`try`",
+                  "Return": "`return`", "Par": "`par`", "Break": "`break`",
+                  "Skip": "`skip`"}
+
+    def _nested_view_stmts(self, stmts, where: str | None, view: str) -> None:
+        """Walk a view's render tree. `where` is None at the view's top
+        level (where state/derive/load/let/assignments are ordinary) and
+        names the enclosing block below it, where only render nodes and
+        element `on` handlers are lowered."""
+        for st in stmts or []:
+            if isinstance(st, A.OnBlock):
+                continue
+            if isinstance(st, A.Element):
+                if st.name == "textarea":
+                    bad = next((b for b in st.body
+                                if not isinstance(b, A.OnBlock)), None)
+                    if bad is not None:
+                        self._d("E-TEXTAREA-CONTENT", Severity.ERROR,
+                                "'textarea' takes no children -- its text is "
+                                "its value, and the build would drop this",
+                                bad, "bind it to a state and give the state "
+                                "its initial text: textarea label:\"Notes\" "
+                                "bind:notes")
+                    continue
+                self._nested_view_stmts(st.body, "'%s'" % st.name, view)
+            elif isinstance(st, A.ListBlock):
+                self._nested_view_stmts(st.body, "a `list` block", view)
+            elif isinstance(st, A.If):
+                for body in [st.then, *(b for _c, b in st.elifs), st.orelse]:
+                    self._nested_view_stmts(body, "an `if` block", view)
+            elif isinstance(st, (A.Match, A.ChildrenMarker)):
+                continue
+            elif where is None:
+                if isinstance(st, A.LoadDecl):
+                    self._nested_view_stmts(st.pending, "a `load` pending block", view)
+                    self._nested_view_stmts(st.error_body, "a `load` error block", view)
+            else:
+                word = self._STMT_WORD.get(type(st).__name__, type(st).__name__)
+                if isinstance(st, (A.StateDecl, A.DeriveDecl, A.LoadDecl, A.Let)):
+                    fix = ("declare it at the top of view '%s', before its "
+                           "elements; for a per-row value inside a `list`, "
+                           "compute it inline or render a child view that "
+                           "takes the row as a prop" % view)
+                else:
+                    fix = ("put it in an `on` handler (such as `on tap`), or "
+                           "in `on mount` at the top of view '%s'" % view)
+                self._d("E-VIEW-STMT-NESTED", Severity.ERROR,
+                        "%s inside %s is not supported -- only elements, "
+                        "`list`, `if` and `on` handlers render there, and the "
+                        "build would drop it" % (word, where), st, fix)
+
     # -- services ----------------------------------------------------
     def services(self, mod: A.Module) -> None:
         for it in mod.items:
@@ -2783,6 +2963,11 @@ class Checker:
         # names the module itself declares or imports: a call to one of these
         # is the author's own function, never the builtin of the same name
         self._module_names = set()
+        self._fn_fields = {
+            f.name for it in mod.items
+            if isinstance(it, (A.TypeDecl, A.ModelDecl))
+            for f in (getattr(it, "fields", None) or [])
+            if getattr(getattr(f, "type", None), "is_fn", False)}
         for it in mod.items:
             nm = getattr(it, "name", None)
             if nm:
@@ -2954,6 +3139,118 @@ class Checker:
                     "the call compiles and throws when it runs" % (nm, nm),
                     call, "use %s" % _FN_NOT_BUILT[nm])
 
+    @staticmethod
+    def _value_receiver(obj, scopes: list[set]) -> bool:
+        """True when `obj` -- the receiver of `obj.m(...)` -- is an ordinary
+        value, so `.m` must be one of the language's value methods. False for
+        a namespace or client (`db.posts...`, `auth`, `route`, `log`, an
+        imported `api` client), an ambient server object, or a name this
+        pass cannot place: those stay lenient."""
+        while True:
+            if isinstance(obj, (A.Member, A.Index)):
+                obj = obj.obj
+            elif isinstance(obj, A.TryOp):
+                obj = obj.operand
+            elif isinstance(obj, A.Call):
+                if not isinstance(obj.callee, A.Member):
+                    return True     # a function / constructor result
+                obj = obj.callee.obj
+            else:
+                break
+        if isinstance(obj, A.Name):
+            n = obj.id
+            if n in _AMBIENT_RECEIVERS:
+                return False
+            owner = next((i for i in range(len(scopes) - 1, -1, -1)
+                          if n in scopes[i]), None)
+            # scopes[0] holds the builtins and module-level names: namespaces,
+            # clients, declarations. A local binding is a value.
+            return owner is not None and owner > 0
+        return isinstance(obj, (A.Literal, A.ListLit, A.RecordLit, A.Binary,
+                                A.Unary, A.IfExpr, A.Range))
+
+    def _interp_expr(self, s: int, e: int):
+        """Parse the `{expr}` at source offsets [s, e) the way `vlbuild`'s
+        `_parse_sub_expr` does, with node offsets moved to the whole file.
+        None when it does not parse (the build reports that itself)."""
+        from .lexer import Lexer
+        from .parser import Parser
+        frag = self.li.text[s:e]
+        try:
+            sub = Parser(Lexer(frag, self.filename).lex(), frag,
+                         self.filename).parse_expr()
+        except Exception:  # noqa: BLE001 -- a bad fragment is not ours to report
+            return None
+        for node in _walk(sub):
+            node.start += s
+            node.end += s
+        return sub
+
+    def _src(self, node, limit: int = 40) -> str | None:
+        """The source text of an expression node for a `fix:` line, or None
+        when it is long or spans lines. Some nodes end at the end of the token
+        after them (the `.` of a member access, the `)` closing the call
+        around them), so a trailing `.` and any unbalanced closer is
+        trimmed."""
+        text = self.li.text[node.start:node.end].strip().rstrip(".").rstrip()
+        for op, cl in (("(", ")"), ("[", "]")):
+            while text.endswith(cl) and text.count(cl) > text.count(op):
+                text = text[:-1].rstrip()
+        return text if text and len(text) <= limit and "\n" not in text else None
+
+    def _check_value_method(self, call, scopes: list[set]) -> None:
+        """E-METHOD-UNKNOWN: `value.m(...)` where `m` is not a method of a
+        Volaro value. See `_VALUE_METHODS` for why this used to throw at run
+        time instead of failing the check."""
+        callee = call.callee
+        if not isinstance(callee, A.Member):
+            return
+        m = callee.name
+        if m in _LOAD_METHODS or m in _PASS_THROUGH_METHODS:
+            return      # E-LOAD-METHOD owns reload / loading
+        if m in self._fn_fields:
+            return      # calling a `fn`-typed record field
+        if not self._value_receiver(callee.obj, scopes):
+            return
+        r = self._src(callee.obj) or "x"
+        if m in _VALUE_METHODS:
+            want = _VALUE_METHODS[m]
+            got = len(call.args) + len(call.named)
+            if got != want:
+                sig = "len()" if m == "len" else "format(pattern)"
+                self._d("E-METHOD-UNKNOWN", Severity.ERROR,
+                        "'.%s' takes %s -- `%s.%s(...)` with %d compiles to a "
+                        "method JavaScript does not have and throws when it runs"
+                        % (m, "no arguments" if want == 0 else "one argument",
+                           r, m, got),
+                        call, "write `%s.%s`" % (r, sig))
+            return
+        fn = _METHOD_FN_FORM.get(m)
+        parts = ([self._src(a) for a in call.args]
+                 + ["%s: %s" % (k, self._src(v)) for k, v in call.named])
+        args = ", ".join(p or "..." for p in parts)
+        if len(args) > 40:
+            args = "..."
+        if fn is not None:
+            if fn in _LIST_FNS:
+                form = "%s |> %s(%s)" % (r, fn, args)
+            elif fn == "contains" and not args:
+                form = "contains(%s, y)" % r
+            else:
+                form = "%s(%s%s)" % (fn, r, (", " + args) if args else "")
+            fix = "write `%s` -- %s is a std function, not a method" % (form, fn)
+        elif m in _METHOD_OTHER_FIX:
+            fix = "write " + _METHOD_OTHER_FIX[m].format(r=r)
+        else:
+            fix = ("a value's only methods are `.len()` and `.format(pattern)` "
+                   "(plus `.reload()` / `.loading()` on a view's `load` name); "
+                   "string and list operations are std functions -- `f(x, ...)` "
+                   "or `x |> f(...)`")
+        self._d("E-METHOD-UNKNOWN", Severity.ERROR,
+                "'.%s()' is not a method of a Volaro value -- the build emits "
+                "`%s.%s(...)` as a raw JavaScript method call, which throws "
+                "when the method does not exist" % (m, r, m), call, fix)
+
     def _check_assign(self, st, scopes: list[set]) -> None:
         """Only a view `state` and a `let mut` can be reassigned (spec 5.1:
         bindings are immutable unless declared `mut`). The binding that counts
@@ -3015,6 +3312,12 @@ class Checker:
                 self._check_builtin_call(A.Call(start=ex.start, end=ex.end,
                                                 callee=A.Name(start=ex.start, end=ex.end, id=nm)),
                                          scopes)
+            # `"{a.title.lower()}"`: the build lowers each `{expr}` as a
+            # full expression, so its method calls are judged the same way.
+            for s, e in getattr(ex, "interp_spans", ()):
+                for node in _walk(self._interp_expr(s, e)):
+                    if isinstance(node, A.Call):
+                        self._check_value_method(node, scopes)
             if self.strict_names:
                 for n in ex.interp_names:
                     if not self._resolve(n, scopes):
@@ -3029,6 +3332,7 @@ class Checker:
             self._expr(ex.index, scopes, fallible)
         elif isinstance(ex, A.Call):
             self._check_builtin_call(ex, scopes)
+            self._check_value_method(ex, scopes)
             callee = ex.callee
             if isinstance(callee, A.Member) and callee.name in _LOAD_METHODS:
                 self._check_load_call(ex, scopes)
@@ -3178,6 +3482,7 @@ def check(mod: A.Module, filename: str, li: LineIndex,
     c = Checker(filename, li, strict_names, release)
     if isinstance(mod, A.PageServerFile):
         c.page_server(mod)
+        c.record_field_names(mod)
         return c.diags
     if isinstance(mod, A.ServerContextFile):
         # Provider expressions get the ambient server names in scope; earlier

package/compiler/validator/vlcheck/parser.py

@@ -1608,6 +1608,7 @@ class Parser:
             lit.interp_names = self._interp_names(t)
             lit.interp_calls = [m.group(1) for s, e in getattr(t, "interps", [])
                                 for m in _CALL_RE.finditer(self.src[s:e])]
+            lit.interp_spans = list(getattr(t, "interps", []))
             return lit
         if self.at_kw("if"):
             return self._parse_if_expr()

package/compiler/validator/vlcheck/resolve.py

@@ -66,6 +66,12 @@ _STD_EXTRA = {
     "replace", "pad_start", "pad_end", "repeat", "now", "uuid4", "random",
     "matches",
 }
+# std.list / std.str functions whose result is a list (E-LIST-OPERATOR);
+# only when the name is not the module's own declaration or a local binding
+_LIST_STD_FNS = {"concat", "append", "filter", "map", "take", "sort_by",
+                 "chunk", "keys", "values", "split"}
+_ARITH = {"+", "-", "*", "/", "%"}
+_COMPOUND_ARITH = {"+=", "-=", "*=", "/="}
 # bare-word identifiers the spec uses in argument position (not bindings)
 _CONTEXTUAL = {"asc", "desc", "google", "github"}
 # Spec §3.4: a component's case carries meaning.
@@ -78,6 +84,10 @@ _UI_STD_VIEWS = {
     "Spinner", "Avatar", "Icon", "Image", "Portal", "Fragment", "Divider",
     "Skeleton", "Badge",
 }
+# The std.ui views this build's runtime actually renders (vlbuild
+# RUNTIME_COMPONENTS). The rest of `_UI_STD_VIEWS` resolves as a name but is
+# E-COMPONENT-UNSUPPORTED at the call site.
+_RUNTIME_VIEWS = {"Spinner"}
 # Spec §11.3, exact: the compiler-owned `auth` client surface, eight calls.
 # Unlike `_STD_EXTRA` (names with no signature to check), the spec gives each of
 # these a parameter list, so an unknown method or a wrong argument here is a
@@ -511,7 +521,10 @@ class Resolver:
                         sc[s.name] = (_tref(s.type)[:2] if s.type
                                       else self._typeof(s.init, [sc]))
                     elif isinstance(s, A.DeriveDecl):
-                        sc[s.name] = None
+                        # only list-ness is tracked for a derive (E-LIST-OPERATOR);
+                        # its element type is left unknown, as before
+                        ti = self._typeof(s.expr, [sc])
+                        sc[s.name] = (None, True) if ti and ti[1] else None
                     elif isinstance(s, A.LoadDecl):
                         sc[s.name] = self._load_type(s, [sc])
                 self._in_view = True
@@ -557,6 +570,9 @@ class Resolver:
         elif isinstance(st, A.Assign):
             self._expr(st.target, scopes)
             self._expr(st.value, scopes)
+            if st.op in _COMPOUND_ARITH:
+                self._check_list_operator(st.op[0], st.target, st.value, st,
+                                          scopes)
         elif isinstance(st, A.ExprStmt):
             self._expr(st.expr, scopes)
         elif isinstance(st, A.Return):
@@ -630,6 +646,8 @@ class Resolver:
         if name[:1].isupper() and name not in _UI_STD_VIEWS and sym is None:
             self._d("R-UNDEF", f"component '{name}' is not defined", st,
                     "declare a view with this name, or check the spelling")
+        elif name[:1].isupper():
+            self._component_shape(st, sym)
         if sym is not None and sym.kind == "view" and sym.params is not None:
             given = {k for k, _ in st.attrs}
             for pn, has_def, is_opt in sym.params:
@@ -644,6 +662,47 @@ class Resolver:
                 self._expr(v, scopes)
         self._scoped(st.body, scopes)
 
+    def _component_shape(self, st: A.Element, sym) -> None:
+        """An uppercase element the build cannot lower as written. Each case
+        used to build with a `warn:` line only: an unknown component became
+        an empty placeholder `div`, and a positional argument or a runtime
+        component's arguments and children were dropped."""
+        name = st.name
+        if sym is None and name in _UI_STD_VIEWS and name not in _RUNTIME_VIEWS:
+            self._d("E-COMPONENT-UNSUPPORTED",
+                    f"'{name}' is not a view this build provides (the only "
+                    f"built-in view is {', '.join(sorted(_RUNTIME_VIEWS))}); "
+                    "the build would render an empty placeholder", st,
+                    f"declare `view {name}(...)` in this project and import it")
+            return
+        if sym is None:                      # a runtime view: Spinner
+            if st.args or st.attrs or any(not isinstance(b, A.OnBlock)
+                                          for b in st.body):
+                self._d("E-COMPONENT-ARGS",
+                        f"'{name}' takes no arguments or children -- the "
+                        "build would drop them", st, f"{name}()")
+            return
+        if sym.kind != "view":
+            what = {"record": "a record type", "union": "a union type",
+                    "alias": "a type alias", "variant": "a union variant",
+                    "fn": "a function", "service": "a service",
+                    "api": "an api client"}.get(sym.kind, "not a view")
+            self._d("E-COMPONENT-NOT-VIEW",
+                    f"'{name}' is {what}"
+                    + (" imported from a package this build cannot compile"
+                       if sym.kind == "opaque" else "")
+                    + " -- only a `view` renders as a component, and the "
+                    "build would emit an empty placeholder", st,
+                    "declare a view with this name, or import one "
+                    "(use ./components { Name })")
+            return
+        if st.args:
+            first = (sym.params or [("name", False, False)])[0][0]
+            self._d("E-COMPONENT-POSITIONAL",
+                    f"'{name}' takes named props, not a positional argument -- "
+                    "the build would drop it", st.args[0],
+                    f"{name}({first}: ...)")
+
     # -------------------------------------------------------------- expressions
     def _expr(self, ex, scopes):
         if ex is None:
@@ -680,6 +739,10 @@ class Resolver:
         elif isinstance(ex, A.Binary):
             self._expr(ex.left, scopes)
             self._expr(ex.right, scopes)
+            if ex.op in _ARITH and not (isinstance(ex.left, A.Binary)
+                                        and ex.left.op in _ARITH
+                                        and self._is_list(ex.left, scopes)):
+                self._check_list_operator(ex.op, ex.left, ex.right, ex, scopes)
         elif isinstance(ex, A.Range):
             self._expr(ex.lo, scopes)
             self._expr(ex.hi, scopes)
@@ -803,7 +866,27 @@ class Resolver:
         if isinstance(ex, A.Index):
             ot = self._typeof(ex.obj, scopes)
             return (ot[0], False) if ot and ot[1] else None
+        if isinstance(ex, A.ListLit):
+            return (None, True)
+        if (isinstance(ex, A.Binary) and ex.op == "|>"
+                and isinstance(ex.right, (A.Call, A.Name))):
+            right = ex.right
+            call = (A.Call(callee=right.callee, args=[ex.left, *right.args],
+                           named=list(right.named))
+                    if isinstance(right, A.Call)
+                    else A.Call(callee=right, args=[ex.left]))
+            return self._typeof(call, scopes)
+        if isinstance(ex, A.Binary) and ex.op in _ARITH:
+            # a list on either side is already an E-LIST-OPERATOR; carrying
+            # the list-ness keeps `a + b + c` to one diagnostic
+            if self._is_list(ex.left, scopes) or self._is_list(ex.right, scopes):
+                return (None, True)
+            return None
         if isinstance(ex, A.Call):
+            if (isinstance(ex.callee, A.Name) and ex.callee.id in _LIST_STD_FNS
+                    and ex.callee.id not in self.table
+                    and not any(ex.callee.id in sc for sc in scopes)):
+                return (None, True)
             if isinstance(ex.callee, A.Member) and isinstance(ex.callee.obj, A.Name) \
                     and (ex.callee.obj.id == "api"
                          or (self.table.get(ex.callee.obj.id) or Sym("x")).kind in ("service", "api")):
@@ -815,6 +898,32 @@ class Resolver:
                     return s.ret
         return None
 
+    def _is_list(self, ex, scopes) -> bool:
+        ti = self._typeof(ex, scopes)
+        return bool(ti and ti[1])
+
+    def _check_list_operator(self, op, left, right, node, scopes) -> None:
+        """E-LIST-OPERATOR: an arithmetic operator with a list operand. The
+        build lowers `+` straight to JavaScript's `+`, which joins two arrays
+        into a STRING (`[1] + [2]` is "12"), so `pub = pub + [x]` checked
+        clean and the next `group_by` over `pub` threw. Spec 20.9: lists grow
+        only through `concat(a, b)` / `append(xs, x)`. Judged only where the
+        resolver can tell a value is a list; an unknown type is skipped."""
+        if not (self._is_list(left, scopes) or self._is_list(right, scopes)):
+            return
+        if op == "+":
+            self._d("E-LIST-OPERATOR",
+                    "'+' does not combine lists -- there is no list `+` "
+                    "(spec 20.9), and the build would join the two lists "
+                    "into a string", node,
+                    "use concat(a, b) or xs |> append(x)")
+        else:
+            self._d("E-LIST-OPERATOR",
+                    f"'{op}' is not defined on a list -- arithmetic operators "
+                    "take numbers", node,
+                    "use a std.list function (filter, map, take, concat, "
+                    "append)")
+
     def _record(self, ti):
         if not ti or ti[1]:
             return None

package/compiler/vlbuild/vlbuild/__main__.py

@@ -328,6 +328,9 @@ def main(argv: list[str]) -> int:
     else:
         print("vlbuild: wrote %s/" % out_dir)
         print("  views:  %s" % ", ".join(v.name for v in emitter.views))
+        if emitter.imported_views:
+            print("  imported views: %s"
+                  % ", ".join(v.name for v in emitter.imported_views))
         print("  routes: %s" % (", ".join("route_" + k for k in emitter.routes) or "(none)"))
         print("  data:   %s" % data_note)
     for w in emitter.warnings:

package/compiler/vlbuild/vlbuild/assets/vlrt.js

@@ -117,6 +117,10 @@
     replace: function (s, target, repl) {
       return String(s).split(String(target)).join(String(repl));
     },
+    // std.str's substring test: case-sensitive, an empty `part` is true.
+    // Distinct from the `where(col: contains(x))` DB predicate, which the
+    // compiler lowers to an `{op: "contains"}` marker instead of this call.
+    contains: function (s, part) { return String(s).indexOf(String(part)) !== -1; },
     first_char: function (s) { return String(s).slice(0, 1); },
     trim: function (s) { return String(s).trim(); },
     upper: function (s) { return String(s).toUpperCase(); },