@traqula/rules-sparql-1-2 0.0.3 → 0.0.5

package/lib/grammar.js

@@ -1,12 +1,6 @@
-/**
- * This module will define patch rules that should be used in combination with the sparql11 grammar to create
- * a sparql12 grammar.
- * Rules in this module redefine the return type of core grammar rules.
- * It is therefore essential that the parser retypes the rules from the core grammar.
- */
-import { funcExpr1, funcExpr3, gram as S11, lex as l11, CommonIRIs, } from '@traqula/rules-sparql-1-1';
+import { CommonIRIs, funcExpr1, funcExpr3, gram as S11, lex as l11 } from '@traqula/rules-sparql-1-1';
 import * as l12 from './lexer';
-import { langTagHasCorrectDomain } from './validator';
+import { langTagHasCorrectRange } from './validator';
 /**
  *[[7]](https://www.w3.org/TR/sparql12-query/#rVersionDecl)
  */
@@ -14,7 +8,7 @@ export const versionDecl = {
     name: 'versionDecl',
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
         const versionToken = CONSUME(l12.version);
-        const identifier = SUBRULE(versionSpecifier, undefined);
+        const identifier = SUBRULE(versionSpecifier);
         return ACTION(() => C.factory.contextDefinitionVersion(identifier.val, C.factory.sourceLocation(versionToken, identifier)));
     },
     gImpl: ({ PRINT_WORDS }) => (ast, { factory: F }) => {
@@ -38,31 +32,31 @@ export const versionSpecifier = {
 };
 /**
  * OVERRIDING RULE {@link S11.prologue}
- * [[8]](https://www.w3.org/TR/sparql12-query/#rVersionSpecifier)
+ * [[4]](https://www.w3.org/TR/sparql12-query/#rPrologue)
  */
 export const prologue = {
     name: 'prologue',
     impl: ({ SUBRULE, MANY, OR }) => () => {
         const result = [];
         MANY(() => OR([
-            { ALT: () => result.push(SUBRULE(S11.baseDecl, undefined)) },
+            { ALT: () => result.push(SUBRULE(S11.baseDecl)) },
             // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
             //  We might need to check this.
-            { ALT: () => result.push(SUBRULE(S11.prefixDecl, undefined)) },
-            { ALT: () => result.push(SUBRULE(versionDecl, undefined)) },
+            { ALT: () => result.push(SUBRULE(S11.prefixDecl)) },
+            { ALT: () => result.push(SUBRULE(versionDecl)) },
         ]));
         return result;
     },
     gImpl: ({ SUBRULE }) => (ast, { factory: F }) => {
         for (const context of ast) {
             if (F.isContextDefinitionBase(context)) {
-                SUBRULE(S11.baseDecl, context, undefined);
+                SUBRULE(S11.baseDecl, context);
             }
             else if (F.isContextDefinitionPrefix(context)) {
-                SUBRULE(S11.prefixDecl, context, undefined);
+                SUBRULE(S11.prefixDecl, context);
             }
             else if (F.isContextDefinitionVersion(context)) {
-                SUBRULE(versionDecl, context, undefined);
+                SUBRULE(versionDecl, context);
             }
         }
     },
@@ -71,8 +65,8 @@ function reifiedTripleBlockImpl(name, allowPath) {
     return {
         name,
         impl: ({ ACTION, SUBRULE }) => (C) => {
-            const triple = SUBRULE(reifiedTriple, undefined);
-            const properties = SUBRULE(allowPath ? S11.propertyListPath : S11.propertyList, { subject: ACTION(() => C.factory.dematerialized(triple.identifier)) });
+            const triple = SUBRULE(reifiedTriple);
+            const properties = SUBRULE(allowPath ? S11.propertyListPath : S11.propertyList, ACTION(() => C.factory.dematerialized(triple.identifier)));
             return ACTION(() => [triple, ...properties]);
         },
     };
@@ -92,8 +86,8 @@ export const reifiedTripleBlockPath = reifiedTripleBlockImpl('reifiedTripleBlock
 export const dataBlockValue = {
     name: 'dataBlockValue',
     impl: $ => C => $.OR2([
-        { ALT: () => S11.dataBlockValue.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(tripleTermData, undefined) },
+        { ALT: () => S11.dataBlockValue.impl($)(C) },
+        { ALT: () => $.SUBRULE(tripleTermData) },
     ]),
 };
 /**
@@ -102,13 +96,13 @@ export const dataBlockValue = {
 export const reifier = {
     name: 'reifier',
     impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
-        CONSUME(l12.tilde);
-        const reifier = OPTION(() => SUBRULE(varOrReifierId, undefined));
+        const tildeToken = CONSUME(l12.tilde);
+        const reifier = OPTION(() => SUBRULE(varOrReifierId));
         return ACTION(() => {
             if (reifier === undefined && !C.parseMode.has('canCreateBlankNodes')) {
                 throw new Error('Cannot create blanknodes in current parse mode');
             }
-            return reifier ?? C.factory.blankNode(undefined, C.factory.sourceLocation());
+            return C.factory.wrap(reifier ?? C.factory.blankNode(undefined, C.factory.sourceLocation()), C.factory.sourceLocation(tildeToken, reifier));
         });
     },
 };
@@ -118,9 +112,9 @@ export const reifier = {
 export const varOrReifierId = {
     name: 'varOrReifierId',
     impl: ({ SUBRULE, OR }) => C => OR([
-        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
-        { ALT: () => SUBRULE(S11.iri, undefined) },
-        { ALT: () => SUBRULE(S11.blankNode, undefined) },
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(S11.blankNode) },
     ]),
 };
 function triplesSameSubjectImpl(name, allowPaths) {
@@ -128,9 +122,9 @@ function triplesSameSubjectImpl(name, allowPaths) {
         name,
         impl: $ => C => $.OR2([
             { ALT: () => allowPaths ?
-                    S11.triplesSameSubjectPath.impl($)(C, undefined) :
-                    S11.triplesSameSubject.impl($)(C, undefined) },
-            { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock, undefined) },
+                    S11.triplesSameSubjectPath.impl($)(C) :
+                    S11.triplesSameSubject.impl($)(C) },
+            { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock) },
         ]),
     };
 }
@@ -147,11 +141,10 @@ export const triplesSameSubjectPath = triplesSameSubjectImpl('triplesSameSubject
 function objectImpl(name, allowPaths) {
     return {
         name,
-        impl: ({ ACTION, SUBRULE }) => (C, arg) => {
-            const objectVal = SUBRULE(allowPaths ? graphNodePath : graphNode, undefined);
-            const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation, undefined);
+        impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
+            const objectVal = SUBRULE(allowPaths ? graphNodePath : graphNode);
+            const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
             return ACTION(() => {
-                const { subject, predicate } = arg;
                 const F = C.factory;
                 if (F.isPathPure(predicate) && annotationVal.length > 0) {
                     throw new Error('Note 17 violation');
@@ -163,12 +156,12 @@ function objectImpl(name, allowPaths) {
 }
 /**
  * OVERRIDING RULE: {@link S11.object}.
- * [[84]](https://www.w3.org/TR/sparql12-query/#rObject) Used by ObjectList
+ * [[86]](https://www.w3.org/TR/sparql12-query/#rObject) Used by ObjectList
  */
 export const object = objectImpl('object', false);
 /**
  * OVERRIDING RULE: {@link S11.objectPath}.
- * [[91]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath) Used by ObjectListPath
+ * [[87]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath) Used by ObjectListPath
  */
 export const objectPath = objectImpl('objectPath', true);
 function annotationImpl(name, allowPaths) {
@@ -180,9 +173,9 @@ function annotationImpl(name, allowPaths) {
             MANY(() => {
                 OR([
                     { ALT: () => {
-                            const node = SUBRULE(reifier, undefined);
+                            const node = SUBRULE(reifier);
                             annotations.push(node);
-                            currentReifier = node;
+                            currentReifier = node.val;
                         } },
                     { ALT: () => {
                             ACTION(() => {
@@ -203,19 +196,19 @@ function annotationImpl(name, allowPaths) {
         },
         gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
             for (const annotation of ast) {
-                if (F.isTerm(annotation)) {
-                    F.printFilter(annotation, () => PRINT_WORD('~'));
-                    SUBRULE(graphNodePath, annotation, undefined);
+                if (F.isTripleCollectionBlankNodeProperties(annotation)) {
+                    SUBRULE(annotationBlockPath, annotation);
                 }
                 else {
-                    SUBRULE(annotationBlockPath, annotation, undefined);
+                    F.printFilter(annotation, () => PRINT_WORD('~'));
+                    SUBRULE(graphNodePath, annotation.val);
                 }
             }
         },
     };
 }
 /**
- * [[107]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
+ * [[109]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
  */
 export const annotationPath = annotationImpl('annotationPath', true);
 /**
@@ -227,7 +220,7 @@ function annotationBlockImpl(name, allowPaths) {
         name,
         impl: ({ ACTION, SUBRULE, CONSUME }) => (C, arg) => {
             const open = CONSUME(l12.annotationOpen);
-            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty, { subject: arg });
+            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty, arg);
             const close = CONSUME(l12.annotationClose);
             return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(arg, res, C.factory.sourceLocation(open, close)));
         },
@@ -236,12 +229,12 @@ function annotationBlockImpl(name, allowPaths) {
             for (const triple of ast.triples) {
                 HANDLE_LOC(triple, () => {
                     if (F.isTerm(triple.predicate)) {
-                        SUBRULE(graphNodePath, triple.predicate, undefined);
+                        SUBRULE(graphNodePath, triple.predicate);
                     }
                     else {
                         SUBRULE(S11.pathGenerator, triple.predicate, undefined);
                     }
-                    SUBRULE(graphNodePath, triple.object, undefined);
+                    SUBRULE(graphNodePath, triple.object);
                     F.printFilter(ast, () => PRINT_WORD(';'));
                 });
             }
@@ -259,13 +252,13 @@ export const annotationBlockPath = annotationBlockImpl('annotationBlockPath', tr
 export const annotationBlock = annotationBlockImpl('annotationBlock', false);
 /**
  * OVERRIDING RULE: {@link S11.graphNode}.
- * [[111]](https://www.w3.org/TR/sparql12-query/#rGraphNode)
+ * [[113]](https://www.w3.org/TR/sparql12-query/#rGraphNode)
  */
 export const graphNode = {
     name: 'graphNode',
     impl: $ => C => $.OR2([
-        { ALT: () => S11.graphNode.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(reifiedTriple, undefined) },
+        { ALT: () => S11.graphNode.impl($)(C) },
+        { ALT: () => $.SUBRULE(reifiedTriple) },
     ]),
 };
 /**
@@ -275,15 +268,15 @@ export const graphNode = {
 export const graphNodePath = {
     name: 'graphNodePath',
     impl: $ => C => $.OR2([
-        { ALT: () => S11.graphNodePath.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(reifiedTriple, undefined) },
+        { ALT: () => S11.graphNodePath.impl($)(C) },
+        { ALT: () => $.SUBRULE(reifiedTriple) },
     ]),
-    gImpl: $ => (ast, C, params) => {
+    gImpl: $ => (ast, C) => {
         if (C.factory.isTripleCollectionReifiedTriple(ast)) {
-            $.SUBRULE(reifiedTriple, ast, undefined);
+            $.SUBRULE(reifiedTriple, ast);
         }
         else {
-            S11.graphNodePath.gImpl($)(ast, C, params);
+            S11.graphNodePath.gImpl($)(ast, C);
         }
     },
 };
@@ -294,96 +287,96 @@ export const graphNodePath = {
 export const varOrTerm = {
     name: 'varOrTerm',
     impl: ({ ACTION, SUBRULE, OR, CONSUME }) => C => OR([
-        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
-        { ALT: () => SUBRULE(S11.iri, undefined) },
-        { ALT: () => SUBRULE(rdfLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.blankNode, undefined) },
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(rdfLiteral) },
+        { ALT: () => SUBRULE(S11.numericLiteral) },
+        { ALT: () => SUBRULE(S11.booleanLiteral) },
+        { ALT: () => SUBRULE(S11.blankNode) },
         { ALT: () => {
                 const token = CONSUME(l11.terminals.nil);
                 return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.NIL));
             } },
-        { ALT: () => SUBRULE(tripleTerm, undefined) },
+        { ALT: () => SUBRULE(tripleTerm) },
     ]),
     // Generation remains untouched - go through graphTerm
 };
 /**
- * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
+ * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
  */
 export const reifiedTriple = {
     name: 'reifiedTriple',
     impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
         const open = CONSUME(l12.reificationOpen);
-        const subject = SUBRULE(reifiedTripleSubject, undefined);
-        const predicate = SUBRULE(S11.verb, undefined);
-        const object = SUBRULE(reifiedTripleObject, undefined);
-        const reifierVal = OPTION(() => SUBRULE(reifier, undefined));
+        const subject = SUBRULE(reifiedTripleSubject);
+        const predicate = SUBRULE(S11.verb);
+        const object = SUBRULE(reifiedTripleObject);
+        const reifierVal = OPTION(() => SUBRULE(reifier));
         const close = CONSUME(l12.reificationClose);
         return ACTION(() => {
             // A reifier would be auto generated in this case, but we are not allowed to use them.
             if (reifierVal === undefined && !C.parseMode.has('canCreateBlankNodes')) {
                 throw new Error('Cannot create blanknodes in current parse mode');
             }
-            return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object, reifierVal);
+            return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object, reifierVal?.val);
         });
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
         F.printFilter(ast, () => PRINT_WORD('<<'));
         const triple = ast.triples[0];
-        SUBRULE(graphNodePath, triple.subject, undefined);
+        SUBRULE(graphNodePath, triple.subject);
         if (F.isPathPure(triple.predicate)) {
             SUBRULE(S11.pathGenerator, triple.predicate, undefined);
         }
         else {
-            SUBRULE(graphNodePath, triple.predicate, undefined);
+            SUBRULE(graphNodePath, triple.predicate);
         }
-        SUBRULE(graphNodePath, triple.object, undefined);
-        SUBRULE(annotationPath, [ast.identifier], undefined);
+        SUBRULE(graphNodePath, triple.object);
+        SUBRULE(annotationPath, [F.wrap(ast.identifier, ast.identifier.loc)]);
         F.printFilter(ast, () => PRINT_WORD('>>'));
     },
 };
 /**
- * [[115]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
+ * [[117]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
  */
 export const reifiedTripleSubject = {
     name: 'reifiedTripleSubject',
     impl: ({ OR, SUBRULE }) => C => OR([
-        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
-        { ALT: () => SUBRULE(S11.iri, undefined) },
-        { ALT: () => SUBRULE(rdfLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.blankNode, undefined) },
-        { ALT: () => SUBRULE(reifiedTriple, undefined) },
-        { ALT: () => SUBRULE(tripleTerm, undefined) },
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(rdfLiteral) },
+        { ALT: () => SUBRULE(S11.numericLiteral) },
+        { ALT: () => SUBRULE(S11.booleanLiteral) },
+        { ALT: () => SUBRULE(S11.blankNode) },
+        { ALT: () => SUBRULE(reifiedTriple) },
+        { ALT: () => SUBRULE(tripleTerm) },
     ]),
 };
 /**
- * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
+ * [[118]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
  */
 export const reifiedTripleObject = {
     name: 'reifiedTripleObject',
     impl: reifiedTripleSubject.impl,
 };
 /**
- * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
+ * [[119]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
  */
 export const tripleTerm = {
     name: 'tripleTerm',
     impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
         const open = CONSUME(l12.tripleTermOpen);
-        const subject = SUBRULE(tripleTermSubject, undefined);
-        const predicate = SUBRULE(S11.verb, undefined);
-        const object = SUBRULE(tripleTermObject, undefined);
+        const subject = SUBRULE(tripleTermSubject);
+        const predicate = SUBRULE(S11.verb);
+        const object = SUBRULE(tripleTermObject);
         const close = CONSUME(l12.tripleTermClose);
         return ACTION(() => C.factory.termTriple(subject, predicate, object, C.factory.sourceLocation(open, close)));
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
         F.printFilter(ast, () => PRINT_WORD('<<('));
-        SUBRULE(graphNodePath, ast.subject, undefined);
-        SUBRULE(graphNodePath, ast.predicate, undefined);
-        SUBRULE(graphNodePath, ast.object, undefined);
+        SUBRULE(graphNodePath, ast.subject);
+        SUBRULE(graphNodePath, ast.predicate);
+        SUBRULE(graphNodePath, ast.object);
         F.printFilter(ast, () => PRINT_WORD(')>>'));
     },
 };
@@ -393,13 +386,13 @@ export const tripleTerm = {
 export const tripleTermSubject = {
     name: 'tripleTermSubject',
     impl: ({ SUBRULE, OR }) => C => OR([
-        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
-        { ALT: () => SUBRULE(S11.iri, undefined) },
-        { ALT: () => SUBRULE(rdfLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.blankNode, undefined) },
-        { ALT: () => SUBRULE(tripleTerm, undefined) },
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(rdfLiteral) },
+        { ALT: () => SUBRULE(S11.numericLiteral) },
+        { ALT: () => SUBRULE(S11.booleanLiteral) },
+        { ALT: () => SUBRULE(S11.blankNode) },
+        { ALT: () => SUBRULE(tripleTerm) },
     ]),
 };
 /**
@@ -416,15 +409,15 @@ export const tripleTermData = {
     name: 'tripleTermData',
     impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
         const open = CONSUME(l12.tripleTermOpen);
-        const subject = SUBRULE(tripleTermDataSubject, undefined);
+        const subject = SUBRULE(tripleTermDataSubject);
         const predicate = OR([
-            { ALT: () => SUBRULE(S11.iri, undefined) },
+            { ALT: () => SUBRULE(S11.iri) },
             { ALT: () => {
                     const token = CONSUME(l11.a);
                     return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE));
                 } },
         ]);
-        const object = SUBRULE(tripleTermDataObject, undefined);
+        const object = SUBRULE(tripleTermDataObject);
         const close = CONSUME(l12.tripleTermClose);
         return ACTION(() => C.factory.termTriple(subject, predicate, object, C.factory.sourceLocation(open, close)));
     },
@@ -435,11 +428,11 @@ export const tripleTermData = {
 export const tripleTermDataSubject = {
     name: 'tripleTermDataSubject',
     impl: ({ OR, SUBRULE }) => () => OR([
-        { ALT: () => SUBRULE(S11.iri, undefined) },
-        { ALT: () => SUBRULE(rdfLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
-        { ALT: () => SUBRULE(tripleTermData, undefined) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(rdfLiteral) },
+        { ALT: () => SUBRULE(S11.numericLiteral) },
+        { ALT: () => SUBRULE(S11.booleanLiteral) },
+        { ALT: () => SUBRULE(tripleTermData) },
     ]),
 };
 /**
@@ -456,20 +449,20 @@ export const tripleTermDataObject = {
 export const primaryExpression = {
     name: 'primaryExpression',
     impl: $ => C => $.OR2([
-        { ALT: () => S11.primaryExpression.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(exprTripleTerm, undefined) },
+        { ALT: () => S11.primaryExpression.impl($)(C) },
+        { ALT: () => $.SUBRULE(exprTripleTerm) },
     ]),
 };
 /**
- * [[135]](https://www.w3.org/TR/sparql12-query/#rExprTripleTerm)
+ * [[137]](https://www.w3.org/TR/sparql12-query/#rExprTripleTerm)
  */
 export const exprTripleTerm = {
     name: 'exprTripleTerm',
     impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
         const open = CONSUME(l12.tripleTermOpen);
-        const subject = SUBRULE(exprTripleTermSubject, undefined);
-        const predicate = SUBRULE(S11.verb, undefined);
-        const object = SUBRULE(exprTripleTermObject, undefined);
+        const subject = SUBRULE(exprTripleTermSubject);
+        const predicate = SUBRULE(S11.verb);
+        const object = SUBRULE(exprTripleTermObject);
         const close = CONSUME(l12.tripleTermClose);
         return ACTION(() => C.factory.termTriple(subject, predicate, object, C.factory.sourceLocation(open, close)));
     },
@@ -480,12 +473,12 @@ export const exprTripleTerm = {
 export const exprTripleTermSubject = {
     name: 'exprTripleTermSubject',
     impl: ({ OR, SUBRULE }) => C => OR([
-        { ALT: () => SUBRULE(S11.iri, undefined) },
-        { ALT: () => SUBRULE(rdfLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
-        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
-        { ALT: () => SUBRULE(exprTripleTerm, undefined) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(rdfLiteral) },
+        { ALT: () => SUBRULE(S11.numericLiteral) },
+        { ALT: () => SUBRULE(S11.booleanLiteral) },
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(exprTripleTerm) },
     ]),
 };
 /**
@@ -495,15 +488,15 @@ export const exprTripleTermObject = {
     name: 'exprTripleTermObject',
     impl: exprTripleTermSubject.impl,
 };
-export const builtinLangDir = funcExpr1(l12.builtinLangDir);
-export const builtinLangStrDir = funcExpr3(l12.builtinStrLangDir);
-export const builtinHasLang = funcExpr1(l12.builtinHasLang);
-export const builtinHasLangDir = funcExpr1(l12.builtinHasLangDir);
-export const builtinIsTriple = funcExpr1(l12.builtinIsTRIPLE);
-export const builtinTriple = funcExpr3(l12.builtinTRIPLE);
-export const builtinSubject = funcExpr1(l12.builtinSUBJECT);
-export const builtinPredicate = funcExpr1(l12.builtinPREDICATE);
-export const builtinObject = funcExpr1(l12.builtinOBJECT);
+export const buildInLangDir = funcExpr1(l12.buildInLangDir);
+export const buildInLangStrDir = funcExpr3(l12.buildInStrLangDir);
+export const buildInHasLang = funcExpr1(l12.buildInHasLang);
+export const buildInHasLangDir = funcExpr1(l12.buildInHasLangDir);
+export const buildInIsTriple = funcExpr1(l12.buildInIsTRIPLE);
+export const buildInTriple = funcExpr3(l12.buildInTRIPLE);
+export const buildInSubject = funcExpr1(l12.buildInSUBJECT);
+export const buildInPredicate = funcExpr1(l12.buildInPREDICATE);
+export const buildInObject = funcExpr1(l12.buildInOBJECT);
 /**
  * OVERRIDING RULE: {@link S11.builtInCall}.
  * [[141]](https://www.w3.org/TR/sparql12-query/#rBuiltInCall)
@@ -511,16 +504,16 @@ export const builtinObject = funcExpr1(l12.builtinOBJECT);
 export const builtInCall = {
     name: 'builtInCall',
     impl: $ => C => $.OR2([
-        { ALT: () => S11.builtInCall.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(builtinLangDir, undefined) },
-        { ALT: () => $.SUBRULE(builtinLangStrDir, undefined) },
-        { ALT: () => $.SUBRULE(builtinHasLang, undefined) },
-        { ALT: () => $.SUBRULE(builtinHasLangDir, undefined) },
-        { ALT: () => $.SUBRULE(builtinIsTriple, undefined) },
-        { ALT: () => $.SUBRULE(builtinTriple, undefined) },
-        { ALT: () => $.SUBRULE(builtinSubject, undefined) },
-        { ALT: () => $.SUBRULE(builtinPredicate, undefined) },
-        { ALT: () => $.SUBRULE(builtinObject, undefined) },
+        { ALT: () => S11.builtInCall.impl($)(C) },
+        { ALT: () => $.SUBRULE(buildInLangDir) },
+        { ALT: () => $.SUBRULE(buildInLangStrDir) },
+        { ALT: () => $.SUBRULE(buildInHasLang) },
+        { ALT: () => $.SUBRULE(buildInHasLangDir) },
+        { ALT: () => $.SUBRULE(buildInIsTriple) },
+        { ALT: () => $.SUBRULE(buildInTriple) },
+        { ALT: () => $.SUBRULE(buildInSubject) },
+        { ALT: () => $.SUBRULE(buildInPredicate) },
+        { ALT: () => $.SUBRULE(buildInObject) },
     ]),
 };
 /**
@@ -531,19 +524,19 @@ export const builtInCall = {
 export const rdfLiteral = {
     name: 'rdfLiteral',
     impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR }) => (C) => {
-        const value = SUBRULE(S11.string, undefined);
+        const value = SUBRULE(S11.string);
         return OPTION(() => OR([
             { ALT: () => {
                     const langTag = CONSUME(l12.LANG_DIR);
                     return ACTION(() => {
                         const literal = C.factory.literalTerm(C.factory.sourceLocation(value, langTag), value.value, langTag.image.slice(1).toLowerCase());
-                        langTagHasCorrectDomain(literal);
+                        langTagHasCorrectRange(literal);
                         return literal;
                     });
                 } },
             { ALT: () => {
                     CONSUME(l11.symbols.hathat);
-                    const iriVal = SUBRULE(S11.iri, undefined);
+                    const iriVal = SUBRULE(S11.iri);
                     return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
                 } },
         ])) ?? value;
@@ -559,23 +552,23 @@ export const generateTriplesBlock = {
             HANDLE_LOC(triple, () => {
                 const nextTriple = ast.triples.at(index);
                 if (F.isTripleCollection(triple)) {
-                    SUBRULE(graphNodePath, triple, undefined);
+                    SUBRULE(graphNodePath, triple);
                     // A top level tripleCollection block means that it is not used in a triple. So you end with DOT.
                     F.printFilter(triple, () => PRINT_WORD('.'));
                 }
                 else {
                     // Subject
-                    SUBRULE(graphNodePath, triple.subject, undefined);
+                    SUBRULE(graphNodePath, triple.subject);
                     // Predicate
                     if (F.isPathPure(triple.predicate)) {
                         SUBRULE(S11.pathGenerator, triple.predicate, undefined);
                     }
                     else {
-                        SUBRULE(graphNodePath, triple.predicate, undefined);
+                        SUBRULE(graphNodePath, triple.predicate);
                     }
                     // Object
-                    SUBRULE(graphNodePath, triple.object, undefined);
-                    SUBRULE(annotationPath, triple.annotations ?? [], undefined);
+                    SUBRULE(graphNodePath, triple.object);
+                    SUBRULE(annotationPath, triple.annotations ?? []);
                     // If no more things, or a top level collection (only possible if new block was part), or new subject: add DOT
                     if (nextTriple === undefined || F.isTripleCollection(nextTriple) ||
                         !F.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
@@ -599,12 +592,12 @@ export const generateTriplesBlock = {
  */
 export const generateGraphTerm = {
     name: 'graphTerm',
-    gImpl: $ => (ast, C, par) => {
+    gImpl: $ => (ast, C) => {
         if (C.factory.isTermTriple(ast)) {
-            $.SUBRULE(tripleTerm, ast, undefined);
+            $.SUBRULE(tripleTerm, ast);
         }
         else {
-            S11.graphTerm.gImpl($)(ast, C, par);
+            S11.graphTerm.gImpl($)(ast, C);
         }
     },
 };