spec: v0.2

spec/tooling: add default case in `build_signature`

spec/tooling: fix hidden global variable

spec/tooling: fix silent side effect

spec/tooling: context manage file reads

spec: fix precedence

Swap precedence of ADD and SUB and treat the first subexpression of a SUB differently

Author: erik-3milabs

spec/expr.typ

@@ -56,8 +56,8 @@
   "div": 5,  // /
   "sum": 6,  // Σ
   "not": 7,  // not
-  "add": 8,  // +
-  "sub": 9,  // -
+  "sub": 8,  // -
+  "add": 9,  // +  
   "eq": 10,   // = and :=
   "MAX": 11, // <the void outside every expression>
 )
@@ -187,7 +187,10 @@
         mwrap($-#rec(PREC.neg, e.at(1))$, pp < PREC.neg)
       } else {
         // Subtraction
-        mwrap($#e.slice(1).map(rec.with(PREC.sub)).join($-$)$, pp < PREC.sub)
+        mwrap(
+          $#rec(PREC.add, e.at(1))-#e.slice(2).map(rec.with(PREC.sub)).join($-$)$,
+          pp <= PREC.sub
+        )
       }
     },
     "cast": (pp, rec, e) => {

spec/tooling/chip.py

@@ -1,3 +1,4 @@
+import copy
 import sys
 import tomllib
 from collections.abc import Callable, Iterable
@@ -390,7 +391,7 @@ def typecheck[T](
             yield from callback(env.with_val(self.name, Range.const(i)))
 
 
-def iters_of(obj: dict, name=None) -> list[Iter]:
+def iters_of(obj: dict, config, name=None) -> list[Iter]:
     """Return a list of iterators needed by `obj`. Taken from `iters` or `iter`.
     Prepend `name` to every iterator, if given.
     Adapted from the corresponding typst implementation."""
@@ -538,7 +539,8 @@ def __init__(self, data: dict):
     @classmethod
     def from_file(cls, filename: str | Path) -> Self:
         reporter.update_location(str(filename))
-        return cls(tomllib.load(open(filename, "rb")))
+        with open(filename, "rb") as fp:
+            return cls(tomllib.load(fp))
 
     @classmethod
     def from_string(cls, s: str) -> Self:
@@ -607,14 +609,14 @@ def __init__(self, config: Config, name: str, tp: Type, data: dict):
             idx = data.get("idx", None)
             self.defs = [
                 PolyWithIters(
-                    build_expr(config, data["poly"]), iters_of(data, name=idx)
+                    build_expr(config, data["poly"]), iters_of(data, config, name=idx)
                 )
             ]
         elif "polys" in data:
             idx = data.get("idx", None)
             self.defs = [
                 PolyWithIters(
-                    build_expr(config, poly["poly"]), iters_of(poly, name=idx)
+                    build_expr(config, poly["poly"]), iters_of(poly, config, name=idx)
                 )
                 for poly in data["polys"]
             ]
@@ -629,6 +631,7 @@ class VirtualVariable(Variable):
     def __init__(self, config: Config, category: str, data: dict):
         assert_no_unexpected(data, (set(Variable.__annotations__.keys()) | {"def"}) - {"pad"})
         reporter.asserts("def" in data, f"Missing def for virtual column: {data!r}")
+        data = copy.deepcopy(data)
         def_ = data.pop("def", {})
         super().__init__(config, category, data)
         self.def_ = VirtualDef(config, self.name, self.type, def_)
@@ -753,7 +756,7 @@ def __init__(self, config: Config, data: dict):
             data, set(self.__annotations__.keys()) | {"iter", "iters", "ref"}
         )
         self.desc = data["desc"]
-        self.iters = iters_of(data)
+        self.iters = iters_of(data, config)
 
 
 @dataclass
@@ -778,7 +781,7 @@ def __init__(self, config: Config, data: dict):
             isinstance(self.desc, str), f"desc is not a string: {self.desc!r}"
         )
         self.poly = build_expr(config, data["poly"])
-        self.iters = iters_of(data)
+        self.iters = iters_of(data, config)
 
     def typecheck(self, env: Environment) -> Iterable[Never]:
         # TODO? Should we check that there's no overflow of the modulus?
@@ -873,7 +876,7 @@ def __init__(self, config: Config, data: dict):
                 f"Missing {self.conditional_name}: {data!r}",
             )
             self.conditional = None
-        self.iters = iters_of(data)
+        self.iters = iters_of(data, config)
 
     def typecheck(self, env: Environment) -> Iterable[Signature]:
         def callback(e: Environment) -> Iterable[Signature]:
@@ -974,7 +977,8 @@ def __init__(self, config: Config, data: dict):
     @classmethod
     def from_file(cls, config: Config, filename: str | Path) -> Self:
         reporter.update_location(str(filename))
-        return cls(config, tomllib.load(open(filename, "rb")))
+        with open(filename, "rb") as fp:
+            return cls(config, tomllib.load(fp))
 
     @classmethod
     def from_string(cls, config: Config, s: str) -> Self:
@@ -1015,6 +1019,9 @@ def build_signature(config: Config, data: dict) -> Signature:
                 "cond" not in data, f"Template signature with cond: {data!r}"
             )
             Sig = InteractionSignature
+        case other:
+            reporter.error(f"Signature of invalid kind '{other}': {data!r}")
+            Sig = Signature
     tag = data["tag"]
     reporter.asserts(isinstance(tag, str), f"Signature tag not a string: {tag!r}")
     input = [build_type(config, inp) for inp in data["input"]]
@@ -1026,7 +1033,8 @@ def build_signature(config: Config, data: dict) -> Signature:
 
 
 def read_signatures(config, filename) -> list[Signature]:
-    data = tomllib.load(open(filename, "rb"))
+    with open(filename, "rb") as fp:
+        data = tomllib.load(fp)
     assert_no_unexpected(data, {"signatures"})
     return [build_signature(config, sig) for sig in data["signatures"]]