volaro 0.0.2 → 0.1.0-alpha.1

package/compiler/validator/vlcheck/__main__.py

@@ -0,0 +1,128 @@
+"""CLI entry point.
+
+    python -m vlcheck <file-or-dir>... [--json] [--quiet] [--strict-names] [--resolve] [--release]
+
+`--release` promotes "unresolved development placeholder" warnings (e.g. an
+`img alt_todo:`) to errors -- the ship gate for unfinished markers.
+
+`--resolve` adds the L1 resolution pass (`resolve.py`) on top of the tolerant
+Stage-1 checks: unknown names / fields / routes, wrong arity, unknown or missing
+named arguments, non-exhaustive `match` over a declared union. It follows `use`
+imports across files. This is the Stage-3 G2 grader for the Volaro arm.
+
+Exit code is non-zero if any error-severity diagnostic is produced.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import os
+import sys
+
+from .checks import check
+from .diagnostics import LineIndex, Severity
+from .lexer import Lexer
+from .parser import Parser
+from .resolve import resolve
+from .project_config import load_config, ConfigError
+from .diagnostics import Diagnostic
+
+
+def _iter_paths(args: list[str]) -> list[str]:
+    out: list[str] = []
+    for a in args:
+        if os.path.isdir(a):
+            out += sorted(glob.glob(os.path.join(a, "**", "*.vl"), recursive=True))
+        elif any(ch in a for ch in "*?["):
+            out += sorted(glob.glob(a, recursive=True))
+        else:
+            out.append(a)
+    return out
+
+
+def check_source(src: str, filename: str, strict_names: bool = False,
+                 do_resolve: bool = False, release: bool = False):
+    li = LineIndex(src)
+    lx = Lexer(src, filename)
+    tokens = lx.lex()
+    parser = Parser(tokens, src, filename)
+    mod = parser.parse_module()
+    diags = (list(lx.diags) + list(parser.diags)
+             + check(mod, filename, li, strict_names=strict_names, release=release))
+    if do_resolve:
+        diags += resolve(mod, filename, li)
+    diags.sort(key=lambda d: (d.start, 0 if d.severity == Severity.ERROR else 1, d.code))
+    return li, diags
+
+
+def main(argv: list[str]) -> int:
+    argv = list(argv)
+    argv = [part for arg in argv for part in (['--config', arg.split('=', 1)[1]]
+            if arg.startswith('--config=') else [arg])]
+    config = None
+    if argv.count('--config') > 1:
+        print('E-CONFIG-OPTION: --config may be supplied only once', file=sys.stderr)
+        return 2
+    if '--config' in argv:
+        i = argv.index('--config')
+        if i + 1 >= len(argv) or argv[i + 1].startswith('--'):
+            print('E-CONFIG-READ: --config requires a path', file=sys.stderr)
+            return 2
+        config = argv[i + 1]
+        del argv[i:i + 2]
+    flags = {a for a in argv if a.startswith("--")}
+    args = [a for a in argv if not a.startswith("--")]
+    as_json = "--json" in flags
+    quiet = "--quiet" in flags
+    strict_names = "--strict-names" in flags
+    do_resolve = "--resolve" in flags
+    release = "--release" in flags
+
+    paths = _iter_paths(args)
+    if not paths:
+        print("usage: python -m vlcheck <file-or-dir>... "
+              "[--json] [--quiet] [--strict-names] [--resolve] [--release] [--config PATH]",
+              file=sys.stderr)
+        return 2
+
+    total_err = total_warn = 0
+    json_rows: list[dict] = []
+
+    for path in paths:
+        try:
+            with open(path, "r", encoding="utf-8") as fh:
+                src = fh.read()
+        except (FileNotFoundError, IsADirectoryError):
+            print(f"error: cannot read {path}", file=sys.stderr)
+            total_err += 1
+            continue
+
+        li, diags = check_source(src, path, strict_names=strict_names,
+                                 do_resolve=do_resolve, release=release)
+        try:
+            load_config(path, config)
+        except ConfigError as exc:
+            diags.append(Diagnostic(exc.code, Severity.ERROR, str(exc), 0, 0, file=path))
+        for d in diags:
+            if d.severity == Severity.ERROR:
+                total_err += 1
+            elif d.severity == Severity.WARNING:
+                total_warn += 1
+            if as_json:
+                json_rows.append(d.to_json(li))
+            elif not quiet or d.severity == Severity.ERROR:
+                print(d.render_human(li))
+                print()
+
+    if as_json:
+        print(json.dumps({"diagnostics": json_rows}, indent=2))
+    else:
+        n = len(paths)
+        print(f"checked {n} file{'s' if n != 1 else ''}: "
+              f"{total_err} error(s), {total_warn} warning(s)")
+    return 1 if total_err else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/compiler/validator/vlcheck/ast_nodes.py

@@ -0,0 +1,397 @@
+"""A plain dataclass AST. Every node carries byte offsets `start` / `end`.
+
+This is intentionally lossy compared to the spec's rowan CST: the validator does
+not format or rewrite source, it only inspects structure. Every field has a
+default so nodes can be built incrementally by the tolerant parser.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Node:
+    start: int = 0
+    end: int = 0
+
+
+# --- items --------------------------------------------------------------
+@dataclass
+class Module(Node):
+    items: list = field(default_factory=list)
+
+
+@dataclass
+class Use(Node):
+    path: str = ""
+    names: list = field(default_factory=list)
+
+
+@dataclass
+class TypeDecl(Node):
+    name: str = ""
+    kind: str = ""          # record | union | alias
+    fields: list = field(default_factory=list)
+    variants: list = field(default_factory=list)
+    alias_of: Any = None
+    distinct: bool = False
+
+
+@dataclass
+class Field(Node):
+    name: str = ""
+    type: Any = None
+    default: Any = None
+    attrs: list = field(default_factory=list)   # model field attrs: pk, unique, ref:User.id
+
+
+@dataclass
+class Variant(Node):
+    name: str = ""
+    params: list = field(default_factory=list)
+
+
+@dataclass
+class ModelDecl(Node):
+    name: str = ""
+    fields: list = field(default_factory=list)
+    indexes: list = field(default_factory=list)
+
+
+@dataclass
+class Param(Node):
+    name: str = ""
+    type: Any = None
+    default: Any = None
+
+
+@dataclass
+class FnDecl(Node):
+    name: str = ""
+    params: list = field(default_factory=list)
+    ret: Any = None
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class TypeRef(Node):
+    name: str = ""
+    args: list = field(default_factory=list)
+    optional: bool = False
+    fallible: bool = False
+    err_type: Any = None
+    is_fn: bool = False
+    fn_params: list = field(default_factory=list)
+    fn_ret: Any = None
+    opt_nested: bool = False   # T?? seen
+
+
+# --- views ------------------------------------------------------------
+@dataclass
+class ViewDecl(Node):
+    name: str = ""
+    params: list = field(default_factory=list)
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class PageDecl(Node):
+    """Module-level page declaration (spec §8.11). Carries the page title and
+    (later) other document-scope properties. `attrs` is [(name, expr)], like an
+    element's — `title:` is required and evaluated at module scope."""
+    attrs: list = field(default_factory=list)
+
+
+@dataclass
+class RecipeDecl(Node):
+    """Project styling recipe. Rows remain directives so validation can stay
+    tolerant while preserving the compact, indentation-based surface."""
+    primitive: str = ""
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class StateDecl(Node):
+    name: str = ""
+    type: Any = None
+    init: Any = None
+
+
+@dataclass
+class DeriveDecl(Node):
+    name: str = ""
+    expr: Any = None
+
+
+@dataclass
+class LoadDecl(Node):
+    name: str = ""
+    expr: Any = None
+    pending: list = field(default_factory=list)
+    error_name: str | None = None
+    error_body: list = field(default_factory=list)
+
+
+@dataclass
+class OnBlock(Node):
+    event: str = ""
+    args: list = field(default_factory=list)
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class ListBlock(Node):
+    src: Any = None
+    var: str = ""
+    key: Any = None
+    has_key: bool = False
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class Element(Node):
+    name: str = ""
+    args: list = field(default_factory=list)     # positional exprs
+    attrs: list = field(default_factory=list)    # [(name, expr)]
+    body: list = field(default_factory=list)
+
+
+# --- api / service / auth -------------------------------------------------
+@dataclass
+class ApiDecl(Node):
+    name: str = ""
+    from_expr: Any = None
+    settings: list = field(default_factory=list)
+    endpoints: list = field(default_factory=list)
+
+
+@dataclass
+class Endpoint(Node):
+    method: str = ""
+    name: str = ""
+    params: list = field(default_factory=list)
+    ret: Any = None
+    settings: list = field(default_factory=list)
+
+
+@dataclass
+class ServiceDecl(Node):
+    name: str = ""
+    is_public: bool = False   # `service X public` — every route public unless it overrides
+    routes: list = field(default_factory=list)
+    settings: list = field(default_factory=list)
+
+
+@dataclass
+class Route(Node):
+    method: str = ""
+    path: str = ""
+    params: list = field(default_factory=list)
+    ret: Any = None
+    guard: Any = None
+    alias: str | None = None   # `... as name` — overrides the generated client name
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class Guard(Node):
+    kind: str = ""          # required | optional | role | owner
+    detail: Any = None
+
+
+@dataclass
+class AuthDecl(Node):
+    settings: list = field(default_factory=list)
+
+
+@dataclass
+class Directive(Node):
+    """Generic setting line: a head word, raw token texts, and an optional block.
+
+    Used for the many free-form configuration lines (api settings, auth providers,
+    service `errors` / `before` / `after`, theme) that the validator records but
+    does not deeply check.
+    """
+    head: str = ""
+    tokens: list = field(default_factory=list)
+    body: list = field(default_factory=list)
+
+
+# --- statements -------------------------------------------------------
+@dataclass
+class Let(Node):
+    name: str = ""
+    mut: bool = False
+    type: Any = None
+    init: Any = None
+    empty_literal_no_type: bool = False
+
+
+@dataclass
+class Assign(Node):
+    target: Any = None
+    op: str = "="
+    value: Any = None
+
+
+@dataclass
+class If(Node):
+    cond: Any = None
+    then: list = field(default_factory=list)
+    elifs: list = field(default_factory=list)   # [(cond, body)]
+    orelse: list = field(default_factory=list)
+    has_else: bool = False
+
+
+@dataclass
+class Match(Node):
+    subject: Any = None
+    arms: list = field(default_factory=list)    # [(pattern, guard, body)]
+
+
+@dataclass
+class For(Node):
+    vars: list = field(default_factory=list)
+    iter: Any = None
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class While(Node):
+    cond: Any = None
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class Par(Node):
+    lets: list = field(default_factory=list)
+
+
+@dataclass
+class Spawn(Node):
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class Try(Node):
+    expr: Any = None
+    catches: list = field(default_factory=list)   # [(pattern, body)]
+
+
+@dataclass
+class Return(Node):
+    value: Any = None
+
+
+@dataclass
+class Break(Node):
+    pass
+
+
+@dataclass
+class Skip(Node):
+    pass
+
+
+@dataclass
+class ExprStmt(Node):
+    expr: Any = None
+
+
+# --- expressions -----------------------------------------------------
+@dataclass
+class Name(Node):
+    id: str = ""
+
+
+@dataclass
+class Literal(Node):
+    kind: str = ""      # int float str bool nil duration
+    raw: str = ""
+    interp_names: list = field(default_factory=list)
+
+
+@dataclass
+class ListLit(Node):
+    items: list = field(default_factory=list)
+    empty: bool = False
+
+
+@dataclass
+class RecordLit(Node):
+    type_name: str | None = None
+    fields: list = field(default_factory=list)   # [(name_or_None, expr)]
+    empty: bool = False
+
+
+@dataclass
+class Call(Node):
+    callee: Any = None
+    args: list = field(default_factory=list)
+    named: list = field(default_factory=list)    # [(name, expr)]
+
+
+@dataclass
+class Member(Node):
+    obj: Any = None
+    name: str = ""
+
+
+@dataclass
+class Index(Node):
+    obj: Any = None
+    index: Any = None
+
+
+@dataclass
+class Unary(Node):
+    op: str = ""
+    operand: Any = None
+
+
+@dataclass
+class Binary(Node):
+    op: str = ""
+    left: Any = None
+    right: Any = None
+
+
+@dataclass
+class TryOp(Node):      # postfix ?
+    operand: Any = None
+
+
+@dataclass
+class IfExpr(Node):
+    cond: Any = None
+    then: Any = None
+    orelse: Any = None
+    has_else: bool = False
+
+
+@dataclass
+class Closure(Node):
+    params: list = field(default_factory=list)
+    ret: Any = None
+    body: Any = None       # expr, or list[stmt]
+
+
+@dataclass
+class MatchExpr(Node):
+    subject: Any = None
+    arms: list = field(default_factory=list)
+
+
+@dataclass
+class Range(Node):
+    lo: Any = None
+    hi: Any = None
+    inclusive: bool = False
+
+
+@dataclass
+class Pattern(Node):
+    binds: list = field(default_factory=list)
+    head: str = ""        # constructor / variant / "_" ; "" for literal & structural patterns