@traqula/rules-sparql-1-1 0.0.1-alpha.176 → 0.0.1

package/lib/grammar/whereClause.js

@@ -1,22 +1,24 @@
 import * as l from '../lexer';
-import { deGroupSingle, isVariable } from '../utils';
+import { checkNote13 } from '../validation/validators';
 import { builtInCall } from './builtIn';
 import { argList, brackettedExpression, expression } from './expression';
-import { graphTerm, var_, varOrIri, varOrTerm } from './general';
+import { var_, varOrIri, varOrTerm } from './general';
 import { booleanLiteral, iri, numericLiteral, rdfLiteral } from './literals';
-import { query, subSelect, valuesClause } from './queryUnit/queryUnit';
-import { triplesBlock } from './tripleBlock';
+import { query, subSelect } from './queryUnit/queryUnit';
+import { graphNodePath, triplesBlock } from './tripleBlock';
 /**
  * [[17]](https://www.w3.org/TR/sparql11-query/#rWhereClause)
  */
 export const whereClause = {
     name: 'whereClause',
-    impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => () => {
-        OPTION(() => {
-            CONSUME(l.where);
-        });
+    impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
+        const where = OPTION(() => CONSUME(l.where));
         const group = SUBRULE(groupGraphPattern, undefined);
-        return ACTION(() => group.patterns);
+        return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where, group)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('WHERE'));
+        SUBRULE(groupGraphPattern, ast.val, undefined);
     },
 };
 /**
@@ -24,56 +26,49 @@ export const whereClause = {
  */
 export const groupGraphPattern = {
     name: 'groupGraphPattern',
-    impl: ({ SUBRULE, CONSUME, OR }) => () => {
-        CONSUME(l.symbols.LCurly);
+    impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
+        const open = CONSUME(l.symbols.LCurly);
         const patterns = OR([
             { ALT: () => [SUBRULE(subSelect, undefined)] },
             { ALT: () => SUBRULE(groupGraphPatternSub, undefined) },
         ]);
-        CONSUME(l.symbols.RCurly);
-        return {
-            type: 'group',
-            patterns,
-        };
+        const close = CONSUME(l.symbols.RCurly);
+        return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const patterns = ast.patterns;
-        const builder = ['{\n'];
-        for (const pattern of patterns) {
-            if ('queryType' in pattern) {
-                builder.push(SUBRULE(query, { ...pattern, prefixes: {} }, undefined));
-            }
-            else if (pattern.type === 'bgp') {
-                builder.push(SUBRULE(triplesBlock, pattern, undefined));
-            }
-            else {
-                builder.push(SUBRULE(graphPatternNotTriples, pattern, undefined));
-            }
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('{'));
+        for (const pattern of ast.patterns) {
+            SUBRULE(generatePattern, pattern, undefined);
         }
-        builder.push('\n}');
-        return builder.join(' ');
+        F.printFilter(ast, () => PRINT_WORD('}'));
     },
 };
-function findBoundVarsFromGroupGraphPattern(pattern, boundedVars) {
-    if ('triples' in pattern) {
-        for (const triple of pattern.triples) {
-            if (isVariable(triple.subject)) {
-                boundedVars.add(triple.subject.value);
-            }
-            if (isVariable(triple.predicate)) {
-                boundedVars.add(triple.predicate.value);
-            }
-            if (isVariable(triple.object)) {
-                boundedVars.add(triple.object.value);
-            }
+export const generatePattern = {
+    name: 'generatePattern',
+    gImpl: ({ SUBRULE }) => (ast, { factory: F }) => {
+        if (ast.type === 'query') {
+            SUBRULE(query, F.querySelect({
+                context: [],
+                datasets: F.datasetClauses([], F.sourceLocation()),
+                where: ast.where,
+                variables: ast.variables,
+                solutionModifiers: ast.solutionModifiers,
+                values: ast.values,
+                distinct: ast.distinct,
+                reduced: ast.reduced,
+            }, ast.loc), undefined);
+        }
+        else if (ast.subType === 'group') {
+            SUBRULE(groupGraphPattern, ast, undefined);
+        }
+        else if (ast.subType === 'bgp') {
+            SUBRULE(triplesBlock, ast, undefined);
         }
-    }
-    else if ('patterns' in pattern) {
-        for (const pat of pattern.patterns) {
-            findBoundVarsFromGroupGraphPattern(pat, boundedVars);
+        else {
+            SUBRULE(graphPatternNotTriples, ast, undefined);
         }
-    }
-}
+    },
+};
 /**
  * [[54]](https://www.w3.org/TR/sparql11-query/#rGroupGraphPatternSub)
  */
@@ -82,43 +77,25 @@ export const groupGraphPatternSub = {
     impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
         const patterns = [];
         const bgpPattern = OPTION1(() => SUBRULE1(triplesBlock, undefined));
-        ACTION(() => {
-            if (bgpPattern) {
-                patterns.push(bgpPattern);
-            }
-        });
+        if (bgpPattern) {
+            patterns.push(bgpPattern);
+        }
         MANY(() => {
             const notTriples = SUBRULE(graphPatternNotTriples, undefined);
             patterns.push(notTriples);
             OPTION2(() => CONSUME(l.symbols.dot));
             const moreTriples = OPTION3(() => SUBRULE2(triplesBlock, undefined));
-            ACTION(() => {
-                if (moreTriples) {
-                    patterns.push(moreTriples);
-                }
-            });
-        });
-        // Check note 13 of the spec.
-        // TODO: currently optimized for case bind is present.
-        //  Since every iteration, even when no bind is present, we walk the tree collecting variables.
-        //  optimize either by: checking whether bind is present, or by keeping track of variables and passing them through
-        ACTION(() => {
-            const boundedVars = new Set();
-            for (const pattern of patterns) {
-                // Element can be bind, in that case, check note 13. If it is not, buildup set of bounded variables.
-                if (pattern.type === 'bind') {
-                    if (boundedVars.has(pattern.variable.value)) {
-                        throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
-                    }
-                }
-                else if (pattern.type === 'group' || pattern.type === 'bgp') {
-                    findBoundVarsFromGroupGraphPattern(pattern, boundedVars);
-                }
+            if (moreTriples) {
+                patterns.push(moreTriples);
             }
         });
+        ACTION(() => checkNote13(patterns));
         return patterns;
     },
 };
+/**
+ * [[56]](https://www.w3.org/TR/sparql11-query/#rGraphPatternNotTriples)
+ */
 export const graphPatternNotTriples = {
     name: 'graphPatternNotTriples',
     impl: ({ SUBRULE, OR }) => () => OR([
@@ -132,24 +109,32 @@ export const graphPatternNotTriples = {
         { ALT: () => SUBRULE(inlineData, undefined) },
     ]),
     gImpl: ({ SUBRULE }) => (ast) => {
-        switch (ast.type) {
+        switch (ast.subType) {
             case 'group':
             case 'union':
-                return SUBRULE(groupOrUnionGraphPattern, ast, undefined);
+                SUBRULE(groupOrUnionGraphPattern, ast, undefined);
+                break;
             case 'optional':
-                return SUBRULE(optionalGraphPattern, ast, undefined);
+                SUBRULE(optionalGraphPattern, ast, undefined);
+                break;
             case 'minus':
-                return SUBRULE(minusGraphPattern, ast, undefined);
+                SUBRULE(minusGraphPattern, ast, undefined);
+                break;
             case 'graph':
-                return SUBRULE(graphGraphPattern, ast, undefined);
+                SUBRULE(graphGraphPattern, ast, undefined);
+                break;
             case 'service':
-                return SUBRULE(serviceGraphPattern, ast, undefined);
+                SUBRULE(serviceGraphPattern, ast, undefined);
+                break;
             case 'filter':
-                return SUBRULE(filter, ast, undefined);
+                SUBRULE(filter, ast, undefined);
+                break;
             case 'bind':
-                return SUBRULE(bind, ast, undefined);
+                SUBRULE(bind, ast, undefined);
+                break;
             case 'values':
-                return SUBRULE(valuesClause, ast.values, undefined);
+                SUBRULE(inlineData, ast, undefined);
+                break;
         }
     },
 };
@@ -158,84 +143,113 @@ export const graphPatternNotTriples = {
  */
 export const optionalGraphPattern = {
     name: 'optionalGraphPattern',
-    impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
-        CONSUME(l.optional);
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const optional = CONSUME(l.optional);
         const group = SUBRULE(groupGraphPattern, undefined);
-        return ACTION(() => ({
-            type: 'optional',
-            patterns: group.patterns,
-        }));
+        return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional, group)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('OPTIONAL'));
+        SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc), undefined);
     },
-    gImpl: ({ SUBRULE }) => ast => `OPTIONAL ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.patterns }, undefined)}`,
 };
 /**
  * [[58]](https://www.w3.org/TR/sparql11-query/#rGraphGraphPattern)
  */
 export const graphGraphPattern = {
     name: 'graphGraphPattern',
-    impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
-        CONSUME(l.graph.graph);
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const graph = CONSUME(l.graph.graph);
         const name = SUBRULE(varOrIri, undefined);
         const group = SUBRULE(groupGraphPattern, undefined);
-        return ACTION(() => ({
-            type: 'graph',
-            name,
-            patterns: group.patterns,
-        }));
+        return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph, group)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('GRAPH'));
+        SUBRULE(varOrTerm, ast.name, undefined);
+        SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc), undefined);
     },
-    gImpl: ({ SUBRULE }) => ast => `GRAPH ${SUBRULE(varOrTerm, ast.name, undefined)} ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.patterns }, undefined)}`,
 };
 /**
  * [[59]](https://www.w3.org/TR/sparql11-query/#rServiceGraphPattern)
  */
 export const serviceGraphPattern = {
     name: 'serviceGraphPattern',
-    impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
-        CONSUME(l.service);
-        const silent = Boolean(OPTION(() => CONSUME(l.silent)));
-        const name = SUBRULE(varOrIri, undefined);
-        const group = SUBRULE(groupGraphPattern, undefined);
-        return {
-            type: 'service',
-            name,
-            silent,
-            patterns: group.patterns,
-        };
+    impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+        const service = CONSUME(l.service);
+        const silent = OPTION(() => {
+            CONSUME(l.silent);
+            return true;
+        }) ?? false;
+        const name = SUBRULE1(varOrIri, undefined);
+        const group = SUBRULE1(groupGraphPattern, undefined);
+        return ACTION(() => C.factory.patternService(name, group.patterns, silent, C.factory.sourceLocation(service, group)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => {
+            PRINT_WORD('SERVICE');
+            if (ast.silent) {
+                PRINT_WORD('SILENT');
+            }
+        });
+        SUBRULE(varOrTerm, ast.name, undefined);
+        SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc), undefined);
     },
-    gImpl: ({ SUBRULE }) => ast => `SERVICE ${ast.silent ? 'SILENT ' : ''}${SUBRULE(varOrTerm, ast.name, undefined)} ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.patterns }, undefined)}`,
 };
 /**
  * [[60]](https://www.w3.org/TR/sparql11-query/#rBind)
  */
 export const bind = {
     name: 'bind',
-    impl: ({ SUBRULE, CONSUME }) => () => {
-        CONSUME(l.bind);
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const bind = CONSUME(l.bind);
         CONSUME(l.symbols.LParen);
         const expressionVal = SUBRULE(expression, undefined);
         CONSUME(l.as);
         const variable = SUBRULE(var_, undefined);
-        CONSUME(l.symbols.RParen);
-        return {
-            type: 'bind',
-            variable,
-            expression: expressionVal,
-        };
+        const close = CONSUME(l.symbols.RParen);
+        return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind, close)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('BIND', '('));
+        SUBRULE(expression, ast.expression, undefined);
+        F.printFilter(ast, () => PRINT_WORD('AS'));
+        SUBRULE(var_, ast.variable, undefined);
+        F.printFilter(ast, () => PRINT_WORD(')'));
     },
-    gImpl: ({ SUBRULE }) => ast => `BIND ( ${SUBRULE(expression, ast.expression, undefined)} AS ${SUBRULE(var_, ast.variable, undefined)} )`,
 };
 /**
  * [[61]](https://www.w3.org/TR/sparql11-query/#rInlineData)
  */
 export const inlineData = {
     name: 'inlineData',
-    impl: ({ SUBRULE, CONSUME }) => () => {
-        CONSUME(l.values);
-        const values = SUBRULE(dataBlock, undefined);
-        return {
-            type: 'values',
-            values,
-        };
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const values = CONSUME(l.values);
+        const datablock = SUBRULE(dataBlock, undefined);
+        return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values, datablock)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        const variables = Object.keys(ast.values[0]);
+        F.printFilter(ast, () => {
+            PRINT_WORD('VALUES', '(');
+            for (const variable of variables) {
+                PRINT_WORD(`?${variable}`);
+            }
+            PRINT_WORD(')', '{');
+        });
+        for (const mapping of ast.values) {
+            F.printFilter(ast, () => PRINT_WORD('('));
+            for (const variable of variables) {
+                if (mapping[variable] === undefined) {
+                    F.printFilter(ast, () => PRINT_WORD('UNDEF'));
+                }
+                else {
+                    SUBRULE(graphNodePath, mapping[variable], undefined);
+                }
+            }
+            F.printFilter(ast, () => PRINT_WORD(')'));
+        }
+        F.printFilter(ast, () => PRINT_WORD('}'));
     },
 };
 /**
@@ -253,18 +267,18 @@ export const dataBlock = {
  */
 export const inlineDataOneVar = {
     name: 'inlineDataOneVar',
-    impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => () => {
+    impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => (C) => {
         const res = [];
         const varVal = SUBRULE(var_, undefined);
         CONSUME(l.symbols.LCurly);
         MANY(() => {
             const value = SUBRULE(dataBlockValue, undefined);
-            ACTION(() => res.push({
-                [`?${varVal.value}`]: value,
-            }));
+            ACTION(() => {
+                res.push({ [varVal.value]: value });
+            });
         });
-        CONSUME(l.symbols.RCurly);
-        return res;
+        const close = CONSUME(l.symbols.RCurly);
+        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
     },
 };
 /**
@@ -272,72 +286,54 @@ export const inlineDataOneVar = {
  */
 export const inlineDataFull = {
     name: 'inlineDataFull',
-    impl: ({ ACTION, OR, MANY1, MANY2, MANY3, MANY4, SUBRULE, CONSUME1, CONSUME2 }) => () => OR([
-        // Grammar rule 64 together with note 11 learns us that a nil should be followed by a nil in DataBlock.
-        {
-            ALT: () => {
-                const res = [];
-                CONSUME1(l.terminals.nil);
-                CONSUME1(l.symbols.LCurly);
-                MANY1(() => {
-                    CONSUME2(l.terminals.nil);
-                    res.push({});
-                });
-                CONSUME1(l.symbols.RCurly);
-                return res;
-            },
-        },
-        {
-            ALT: () => {
-                const res = [];
-                const vars = [];
-                CONSUME1(l.symbols.LParen);
-                MANY2(() => {
-                    vars.push(SUBRULE(var_, undefined));
-                });
-                CONSUME1(l.symbols.RParen);
-                CONSUME2(l.symbols.LCurly);
-                MANY3(() => {
-                    const varBinds = [];
-                    CONSUME2(l.symbols.LParen);
-                    MANY4({
-                        DEF: () => {
+    impl: ({ ACTION, OR, MANY1, MANY2, MANY3, MANY4, SUBRULE, CONSUME1, CONSUME2, }) => (C) => {
+        const res = [];
+        const vars = [];
+        return OR([
+            { ALT: () => {
+                    // Grammar rule 64 together with note 11 learns us that a nil should be followed by a nil in DataBlock.
+                    const nil = CONSUME1(l.terminals.nil);
+                    CONSUME1(l.symbols.LCurly);
+                    MANY1(() => {
+                        CONSUME2(l.terminals.nil);
+                        res.push({});
+                    });
+                    const close = CONSUME1(l.symbols.RCurly);
+                    return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil, close)));
+                } },
+            { ALT: () => {
+                    const open = CONSUME1(l.symbols.LParen);
+                    MANY2(() => {
+                        vars.push(SUBRULE(var_, undefined));
+                    });
+                    CONSUME1(l.symbols.RParen);
+                    CONSUME2(l.symbols.LCurly);
+                    MANY3(() => {
+                        let parsedValues = 0;
+                        const currentRow = {};
+                        CONSUME2(l.symbols.LParen);
+                        MANY4(() => {
+                            if (parsedValues >= vars.length) {
+                                throw new Error('Number of dataBlockValues does not match number of variables. Too much values.');
+                            }
+                            const value = SUBRULE(dataBlockValue, undefined);
                             ACTION(() => {
-                                if (vars.length <= varBinds.length) {
-                                    throw new Error('Number of dataBlockValues does not match number of variables. Too much values.');
-                                }
+                                currentRow[vars[parsedValues].value] = value;
+                                parsedValues++;
                             });
-                            varBinds.push(SUBRULE(dataBlockValue, undefined));
-                        },
+                        });
+                        CONSUME2(l.symbols.RParen);
+                        ACTION(() => {
+                            res.push(currentRow);
+                            if (vars.length !== parsedValues) {
+                                throw new Error('Number of dataBlockValues does not match number of variables. Too few values.');
+                            }
+                        });
                     });
-                    CONSUME2(l.symbols.RParen);
-                    ACTION(() => {
-                        if (varBinds.length !== vars.length) {
-                            throw new Error('Number of dataBlockValues does not match number of variables. Too few values.');
-                        }
-                        const row = {};
-                        for (const [index, varVal] of vars.entries()) {
-                            row[`?${varVal.value}`] = varBinds[index];
-                        }
-                        res.push(row);
-                    });
-                });
-                CONSUME2(l.symbols.RCurly);
-                return res;
-            },
-        },
-    ]),
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const variables = Object.keys(ast[0]);
-        const variableString = `( ${variables.join(' ')} )`;
-        const values = ast.map((mapping) => {
-            const valueString = variables.map((variable) => {
-                const value = mapping[variable];
-                return value ? SUBRULE(dataBlockValue, value, undefined) : 'UNDEF';
-            }).join(' ');
-            return `( ${valueString} )`;
-        });
-        return `VALUES ${variableString} { ${values.join(' ')} }`;
+                    const close = CONSUME2(l.symbols.RCurly);
+                    return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
+                } },
+        ]);
     },
 };
 /**
@@ -350,65 +346,58 @@ export const dataBlockValue = {
         { ALT: () => SUBRULE(rdfLiteral, undefined) },
         { ALT: () => SUBRULE(numericLiteral, undefined) },
         { ALT: () => SUBRULE(booleanLiteral, undefined) },
-        {
-            ALT: () => {
+        { ALT: () => {
                 CONSUME(l.undef);
                 // eslint-disable-next-line unicorn/no-useless-undefined
                 return undefined;
-            },
-        },
+            } },
     ]),
-    gImpl: ({ SUBRULE }) => (ast) => {
-        if (ast) {
-            return SUBRULE(graphTerm, ast, undefined);
-        }
-        return 'UNDEF';
-    },
 };
 /**
  * [[66]](https://www.w3.org/TR/sparql11-query/#rMinusGraphPattern)
  */
 export const minusGraphPattern = {
     name: 'minusGraphPattern',
-    impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
-        CONSUME(l.minus);
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const minus = CONSUME(l.minus);
         const group = SUBRULE(groupGraphPattern, undefined);
-        return ACTION(() => ({
-            type: 'minus',
-            patterns: group.patterns,
-        }));
+        return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus, group)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('MINUS'));
+        SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc), undefined);
     },
-    gImpl: ({ SUBRULE }) => ast => `MINUS ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.patterns }, undefined)}`,
 };
 /**
  * [[67]](https://www.w3.org/TR/sparql11-query/#rGroupOrUnionGraphPattern)
  */
 export const groupOrUnionGraphPattern = {
     name: 'groupOrUnionGraphPattern',
-    impl: ({ AT_LEAST_ONE_SEP, SUBRULE }) => () => {
+    impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => {
         const groups = [];
-        AT_LEAST_ONE_SEP({
-            DEF: () => {
-                const group = SUBRULE(groupGraphPattern, undefined);
-                groups.push(group);
-            },
-            SEP: l.union,
+        const group = SUBRULE1(groupGraphPattern, undefined);
+        groups.push(group);
+        MANY(() => {
+            CONSUME(l.union);
+            const group = SUBRULE2(groupGraphPattern, undefined);
+            groups.push(group);
         });
-        return groups.length === 1 ?
+        return ACTION(() => groups.length === 1 ?
             groups[0] :
-            {
-                type: 'union',
-                patterns: groups.map(group => deGroupSingle(group)),
-            };
+            C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        if (ast.type === 'group') {
-            return SUBRULE(groupGraphPattern, ast, undefined);
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        if (F.isPatternUnion(ast)) {
+            const [head, ...tail] = ast.patterns;
+            SUBRULE(groupGraphPattern, head, undefined);
+            for (const pattern of tail) {
+                F.printFilter(ast, () => PRINT_WORD('UNION'));
+                SUBRULE(groupGraphPattern, pattern, undefined);
+            }
+        }
+        else {
+            SUBRULE(groupGraphPattern, ast, undefined);
         }
-        return ast.patterns.map(pattern => SUBRULE(groupGraphPattern, {
-            type: 'group',
-            patterns: [pattern],
-        }, undefined)).join(' UNION ');
     },
 };
 /**
@@ -416,15 +405,16 @@ export const groupOrUnionGraphPattern = {
  */
 export const filter = {
     name: 'filter',
-    impl: ({ SUBRULE, CONSUME }) => () => {
-        CONSUME(l.filter);
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const filterToken = CONSUME(l.filter);
         const expression = SUBRULE(constraint, undefined);
-        return {
-            type: 'filter',
-            expression,
-        };
+        return ACTION(() => C.factory.patternFilter(expression, C.factory.sourceLocation(filterToken, expression)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('FILTER ('));
+        SUBRULE(expression, ast.expression, undefined);
+        F.printFilter(ast, () => PRINT_WORD(')'));
     },
-    gImpl: ({ SUBRULE }) => ast => `FILTER ( ${SUBRULE(expression, ast.expression, undefined)} )`,
 };
 /**
  * [[69]](https://www.w3.org/TR/sparql11-query/#rConstraint)
@@ -442,13 +432,10 @@ export const constraint = {
  */
 export const functionCall = {
     name: 'functionCall',
-    impl: ({ ACTION, SUBRULE }) => () => {
+    impl: ({ ACTION, SUBRULE }) => (C) => {
         const func = SUBRULE(iri, undefined);
         const args = SUBRULE(argList, undefined);
-        return ACTION(() => ({
-            ...args,
-            function: func,
-        }));
+        return ACTION(() => C.factory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.factory.sourceLocation(func, args)));
     },
 };
 //# sourceMappingURL=whereClause.js.map