simple-graph-query 2.7.0 → 2.8.1

package/dist/simple-graph-query.bundle.js

@@ -48590,7 +48590,7 @@ function bitwidthWraparound(value, bitwidth) {
 // this is a list of forge builtin functions we currently support; add to this
 // list as we support more
 const SUPPORTED_BINARY_BUILTINS = ["add", "subtract", "multiply", "divide", "remainder"];
-const SUPPORTED_UNARY_BUILTINS = ["abs", "sign"];
+const SUPPORTED_UNARY_BUILTINS = ["abs", "sign", "floor", "ceil"];
 const SUPPORTED_SET_BUILTINS = ["min", "max"];
 exports.SUPPORTED_BUILTINS = SUPPORTED_BINARY_BUILTINS.concat(SUPPORTED_UNARY_BUILTINS, SUPPORTED_SET_BUILTINS);
 /**
@@ -48626,10 +48626,19 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             // Convert numeric and boolean strings to their actual types
             relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
             relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.convertToBoolean(value) : value));
-            this.relationCache.set(relation.name, relationAtoms);
-            // Build index for this relation: first element -> all tuples starting with that element
+            // Relation NAMES are not unique — only the qualified id (`Sig<:label`) is.
+            // e.g. `open util/ordering[A]` and `open util/ordering[B]` both expose a field
+            // named `Next` (`A/Ord<:Next` and `B/Ord<:Next`). A bare-name reference must
+            // resolve to the UNION of every relation sharing that name; keying by name and
+            // overwriting silently erases all but the last. https://github.com/sidprasad/simple-graph-query/issues/55
+            const existing = this.relationCache.get(relation.name);
+            this.relationCache.set(relation.name, existing ? existing.concat(relationAtoms) : relationAtoms);
+        }
+        // Build first-element indexes from the merged (union'd) tuples, so an index
+        // never reflects only a subset of a name's relations.
+        for (const [name, tuples] of this.relationCache.entries()) {
             const relationIndex = new Map();
-            for (const tuple of relationAtoms) {
+            for (const tuple of tuples) {
                 if (tuple.length > 0) {
                     const key = tuple[0];
                     if (!relationIndex.has(key)) {
@@ -48638,7 +48647,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     relationIndex.get(key).push(tuple);
                 }
             }
-            this.relationIndexCache.set(relation.name, relationIndex);
+            this.relationIndexCache.set(name, relationIndex);
         }
     }
     //helper function
@@ -48978,6 +48987,46 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 varNames.push(varName);
                 quantifiedSets.push(varQuantifiedSets[varName]);
             }
+            // `sum <decls> | <intExpr>`: accumulate the numeric body over every
+            // binding of the quantified variables. Unlike the boolean quantifiers
+            // below, the body evaluates to a number, so this needs its own loop --
+            // and it must not use the boolean numeric-comparison optimization, which
+            // skips body evaluation entirely.
+            if (ctx.quant().SUM_TOK()) {
+                const sumCombinations = getCombinations(quantifiedSets);
+                const sumEnv = { env: {}, type: "quantDecl" };
+                this.environmentStack.push(sumEnv);
+                let total = 0;
+                for (const tuple of sumCombinations) {
+                    if (isDisjoint) {
+                        const seen = new Set();
+                        let tupleDisjoint = true;
+                        for (const val of tuple) {
+                            if (seen.has(val)) {
+                                tupleDisjoint = false;
+                                break;
+                            }
+                            seen.add(val);
+                        }
+                        if (!tupleDisjoint) {
+                            continue;
+                        }
+                    }
+                    for (let j = 0; j < varNames.length; j++) {
+                        sumEnv.env[varNames[j]] = tuple[j];
+                    }
+                    const bodyValue = this.visit(barExpr);
+                    const bodyNumber = extractNumber(bodyValue);
+                    if (bodyNumber === undefined) {
+                        this.environmentStack.pop();
+                        throw new Error("Expected the expression after the bar in a `sum` to evaluate to a number!");
+                    }
+                    total += bodyNumber;
+                }
+                this.environmentStack.pop();
+                this.cacheResult(ctx, freeVarsKey, total);
+                return total;
+            }
             // Try to optimize numeric comparisons
             let product;
             let useOptimizedPath = false;
@@ -49124,7 +49173,8 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return value;
                 }
             }
-            // TODO: don't have support for SUM_TOK yet
+            // NOTE: SUM_TOK is handled above (it returns a number, not a boolean),
+            // before this boolean-quantifier result logic.
         }
         // TODO: fix this!
         const childrenResults = this.visitChildren(ctx);
@@ -50358,7 +50408,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 result = arg1 * arg2;
                 break;
             case "divide":
-                result = Math.floor(arg1 / arg2); // Integer division
+                result = arg1 / arg2; // Real (floating-point) division
                 break;
             case "remainder":
                 result = arg1 % arg2;
@@ -50369,17 +50419,17 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         return result;
     }
     evaluateUnaryOperation(operation, args) {
-        if (!isSingleValue(args) || !isNumber(args)) {
+        const v = extractNumber(args);
+        if (v === undefined) {
             throw new Error(`Expected 1 argument for ${operation} that evaluates to a number.`);
         }
-        let v = args;
         // Possible unary operations:
-        //abs[]: returns the absolute value of value
-        //sign[]: returns 1 if value is > 0, 0 if value is 0, and -1 if value is < 0
+        //abs[]:   returns the absolute value of value
+        //sign[]:  returns 1 if value is > 0, 0 if value is 0, and -1 if value is < 0
+        //floor[]: rounds value down to the nearest integer
+        //ceil[]:  rounds value up to the nearest integer
         if (operation === "abs") {
-            let res = Math.abs(v);
-            // Now adjust to the bitwidth
-            return res;
+            return Math.abs(v);
         }
         else if (operation === "sign") {
             if (v > 0) {
@@ -50392,6 +50442,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 return 0;
             }
         }
+        else if (operation === "floor") {
+            return Math.floor(v);
+        }
+        else if (operation === "ceil") {
+            return Math.ceil(v);
+        }
         else {
             throw new Error(`Unsupported operation: ${operation}`);
         }
@@ -50821,10 +50877,17 @@ const UNKNOWN = { kind: "unknown" };
 class SchemaInfo {
     constructor(schema) {
         this.typesById = new Map(schema.getTypes().map((t) => [t.id, t]));
-        this.relationsByName = new Map(schema.getRelations().map((r) => [r.name, r]));
+        this.relationsByName = new Map();
+        for (const r of schema.getRelations()) {
+            const existing = this.relationsByName.get(r.name);
+            if (existing)
+                existing.push(r);
+            else
+                this.relationsByName.set(r.name, [r]);
+        }
     }
     getType(id) { return this.typesById.get(id); }
-    getRelation(name) { return this.relationsByName.get(name); }
+    getRelations(name) { return this.relationsByName.get(name) ?? []; }
     // A ⊆ B when B is in A's lineage. `IType.types` is the lineage in ascending
     // order, conventionally starting with the type itself.
     isSubtypeOf(a, b) {
@@ -50965,7 +51028,7 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
         if (!this.schema)
             return undefined;
         for (const name of names) {
-            if (this.schema.getType(name) || this.schema.getRelation(name)) {
+            if (this.schema.getType(name) || this.schema.getRelations(name).length > 0) {
                 return {
                     kind: "ill-typed",
                     reason: `cannot bind variable named '${name}': it is a reserved schema ` +
@@ -51746,11 +51809,26 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
             const t = this.schema.getType(id);
             if (t)
                 return { kind: "typed", arity: 1, columnTypes: [t.id] };
-            const r = this.schema.getRelation(id);
-            if (r) {
-                const cols = r.types;
+            const rels = this.schema.getRelations(id);
+            if (rels.length === 1) {
+                const cols = rels[0].types;
                 return { kind: "typed", arity: cols.length, columnTypes: cols };
             }
+            if (rels.length > 1) {
+                // A bare name denotes the union of every relation sharing it. Different
+                // arities have no single typing, so stay UNKNOWN. When arities agree,
+                // keep the arity; keep per-column types only where every relation agrees
+                // (otherwise omit, so downstream disjointness checks soundly skip rather
+                // than fire on a widened column).
+                const arity = rels[0].types.length;
+                if (rels.every((r) => r.types.length === arity)) {
+                    const cols = rels[0].types.map((col, i) => rels.every((r) => r.types[i] === col) ? col : undefined);
+                    const allKnown = cols.every((c) => c !== undefined);
+                    return allKnown
+                        ? { kind: "typed", arity, columnTypes: cols }
+                        : { kind: "typed", arity };
+                }
+            }
         }
         return UNKNOWN;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-graph-query",
-  "version": "2.7.0",
+  "version": "2.8.1",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",
@@ -33,10 +33,15 @@
     "prepublishOnly": "npm run build:full",
     "serve": "python3 -m http.server 8080",
     "test": "jest",
-    "antlr4ts": "cd src/forge-antlr && antlr4ts -visitor ForgeLexer.g4 Forge.g4 && cd ../.."
+    "antlr4ts": "cd src/forge-antlr && antlr4ts -visitor ForgeLexer.g4 Forge.g4 && cd ../..",
+    "release:tag": "git diff-index --quiet HEAD -- || (echo 'Working tree is dirty, commit first' && exit 1) && git tag v$npm_package_version && git push origin v$npm_package_version"
   },
   "author": "Siddhartha Prasad",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sidprasad/simple-graph-query.git"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "antlr4ts-cli": "^0.5.0-alpha.4",