semi compiling parser

Author: jitsedesmet

packages/core/lib/CoreFactory.ts

@@ -11,7 +11,7 @@ import type {
 } from './nodeTypings';
 
 export class CoreFactory {
-  public sourceLocation(...elements: (IToken | SourceLocation)[]): SourceLocation {
+  public sourceLocation(...elements: (Pick<IToken, 'startOffset' | 'endOffset'> | SourceLocation)[]): SourceLocation {
     const filtered =
       elements.filter(element => !this.isSourceLocation(element) || this.isSourceLocationSource(element));
     if (filtered.length === 0) {

packages/rules-sparql-1-1/lib/RoundTripTypes.ts

@@ -93,7 +93,7 @@ export type UpdateOperation =
 export type Update = Node & {
   type: 'update';
   updates: {
-    operation: UpdateOperation;
+    operation?: UpdateOperation;
     context: ContextDefinition[];
   }[];
 };
@@ -220,6 +220,9 @@ export type PatternService = PatternBase & {
   silent: boolean;
   patterns: Pattern[];
 };
+/**
+ * A single list of assignments maps the variable identifier to the value
+ */
 export type ValuePatternRow = Record<string, TermIri | TermBlank | TermLiteral | undefined>;
 export type PatternValues = PatternBase & {
   patternType: 'values';
@@ -247,7 +250,7 @@ export type SolutionModifiers = {
   limitOffset?: SolutionModifierLimitOffset;
 };
 export type SolutionModifierBase = Node & { type: 'solutionModifier'; modifierType: string };
-export type SolutionModifierGroupBind = {
+export type SolutionModifierGroupBind = Pick<Node, 'loc'> & {
   variable: TermVariable;
   value: Expression;
 };
@@ -261,7 +264,7 @@ export type SolutionModifierHaving = SolutionModifierBase & {
 };
 export type Ordering =
   | Expression
-  | ({ descending: boolean; expression: Expression });
+  | ({ descending: boolean; expression: Expression } & Pick<Node, 'loc'>);
 export type SolutionModifierOrder = SolutionModifierBase & {
   modifierType: 'order';
   orderDefs: Ordering[];
@@ -299,6 +302,11 @@ export type ExpressionOperation = ExpressionBase & {
   args: Expression[];
 };
 
+export type ExpressionBracketted = ExpressionBase & {
+  expressionType: 'bracketted';
+  expression: Expression;
+};
+
 export type ExpressionPatternOperation = ExpressionBase & {
   expressionType: 'patternOperation';
   operator: string;
@@ -315,6 +323,7 @@ export type ExpressionFunctionCall = ExpressionBase & {
 
 export type Expression =
   | ExpressionOperation
+  | ExpressionBracketted
   | ExpressionPatternOperation
   | ExpressionFunctionCall
   | ExpressionAggregate

packages/rules-sparql-1-1/lib/expressionHelpers.ts

@@ -155,7 +155,7 @@ RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression] | [Expressi
         const close = CONSUME(l.symbols.RParen);
         return ACTION(() => C.factory.expressionOperation(
           operator.image,
-          [ arg1, arg2, ...(arg3 ? [ arg3 ] : []) ],
+          arg3 ? <const> [ arg1, arg2, arg3 ] : <const> [ arg1, arg2 ],
           C.factory.sourceLocation(operator, close),
         ));
       },
@@ -196,7 +196,7 @@ RuleDefExpressionFunctionX<
         const close = CONSUME(l.symbols.RParen);
         return ACTION(() => C.factory.expressionOperation(
           operator.image,
-          [ arg1, arg2, arg3, ...(arg4 ? [ arg4 ] : []) ],
+          arg4 ? <const> [ arg1, arg2, arg3, arg4 ] : <const> [ arg1, arg2, arg3 ],
           C.factory.sourceLocation(operator, close),
         ));
       },
@@ -212,7 +212,7 @@ SparqlGrammarRule<Uncapitalize<T>, ExpressionPatternOperation> {
       const group = SUBRULE(groupGraphPattern, undefined);
       return ACTION(() => C.factory.expressionPatternOperation(
         operator.image,
-        [ C.factory.deGroupSingle(group)(undefined) ],
+        [ C.factory.deGroupSingle(group) ],
         C.factory.sourceLocation(operator, group.loc),
       ));
     },

packages/rules-sparql-1-1/lib/factory.ts

@@ -16,7 +16,9 @@ import type {
   ExpressionPatternOperation,
   GraphNode,
   GraphRef,
+  GraphRefAll,
   GraphRefDefault,
+  GraphRefNamed,
   GraphRefSpecific,
   Ordering,
   Path,
@@ -28,10 +30,13 @@ import type {
   PatternBgp,
   PatternBind,
   PatternFilter,
+  PatternGraph,
   PatternGroup,
   PatternMinus,
+  PatternOptional,
   PatternService,
   PatternUnion,
+  PatternValues,
   PropertyPathChain,
   Quads,
   Query,
@@ -62,6 +67,7 @@ import type {
   UpdateOperationLoad,
   UpdateOperationModify,
   UpdateOperationMove,
+  ValuePatternRow,
   Wildcard,
 } from './RoundTripTypes';
 
@@ -78,7 +84,7 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
-  public baseDecl(loc: SourceLocation, img1: string, value: TermIriFull): ContextDefinitionBaseDecl {
+  public baseDecl(loc: SourceLocation, value: TermIriFull): ContextDefinitionBaseDecl {
     return {
       type: 'contextDef',
       contextType: 'base',
@@ -186,6 +192,22 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
+  public expressionFunctionCall<Args extends Expression[]>(
+    functionOp: TermIri,
+    args: Args,
+    distinct: boolean,
+    loc: SourceLocation,
+  ): ExpressionFunctionCall & { args: Args } {
+    return {
+      type: 'expression',
+      expressionType: 'functionCall',
+      function: functionOp,
+      args,
+      distinct,
+      loc,
+    };
+  }
+
   public expressionPatternOperation<Args extends Pattern[]>(
     operator: string,
     args: Args,
@@ -231,6 +253,22 @@ export class TraqulaFactory extends CoreFactory {
     return { type: 'pattern', patternType: 'bgp', triples, loc };
   }
 
+  public patternGroup(patterns: Pattern[], loc: SourceLocation): PatternGroup {
+    return { type: 'pattern', patternType: 'group', patterns, loc };
+  }
+
+  public patternGraph(name: TermIri | TermVariable, patterns: Pattern[], loc: SourceLocation): PatternGraph {
+    return { type: 'pattern', patternType: 'graph', name, patterns, loc };
+  }
+
+  public patternOptional(patterns: Pattern[], loc: SourceLocation): PatternOptional {
+    return { type: 'pattern', patternType: 'optional', patterns, loc };
+  }
+
+  public patternValues(values: ValuePatternRow[], loc: SourceLocation): PatternValues {
+    return { type: 'pattern', patternType: 'values', values, loc };
+  }
+
   public patternFilter(expression: Expression, loc: SourceLocation): PatternFilter {
     return {
       type: 'pattern',
@@ -288,6 +326,39 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
+  public graphRefSpecific(graph: TermIri, loc: SourceLocation): GraphRefSpecific {
+    return {
+      type: 'graphRef',
+      graphRefType: 'specific',
+      graph,
+      loc,
+    };
+  }
+
+  public graphRefDefault(loc: SourceLocation): GraphRefDefault {
+    return {
+      type: 'graphRef',
+      graphRefType: 'default',
+      loc,
+    };
+  }
+
+  public graphRefNamed(loc: SourceLocation): GraphRefNamed {
+    return {
+      type: 'graphRef',
+      graphRefType: 'named',
+      loc,
+    };
+  }
+
+  public graphRefAll(loc: SourceLocation): GraphRefAll {
+    return {
+      type: 'graphRef',
+      graphRefType: 'all',
+      loc,
+    };
+  }
+
   public deGroupSingle(group: PatternGroup & Pattern): Pattern {
     if (group.patterns.length === 1) {
       return group.patterns[0];
@@ -504,12 +575,22 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
-  private updateOperationClearDrop<T extends 'clear' | 'drop' | 'create', Dest extends GraphRef>(
-    operationType: T,
+  public updateOperationClearDrop(operationType: 'clear', silent: boolean, destination: GraphRef, loc: SourceLocation):
+  UpdateOperationClear;
+  public updateOperationClearDrop(operationType: 'drop', silent: boolean, destination: GraphRef, loc: SourceLocation):
+  UpdateOperationDrop;
+  public updateOperationClearDrop(
+    operationType: 'clear' | 'drop',
     silent: boolean,
-    destination: Dest,
+    destination: GraphRef,
+    loc: SourceLocation
+  ): UpdateOperationClear | UpdateOperationDrop;
+  public updateOperationClearDrop(
+    operationType: 'clear' | 'drop',
+    silent: boolean,
+    destination: GraphRef,
     loc: SourceLocation,
-  ): Omit<UpdateOperationDrop, 'destination' | 'operationType'> & { operationType: T; destination: Dest } {
+  ): UpdateOperationClear | UpdateOperationDrop {
     return {
       type: 'updateOperation',
       operationType,
@@ -540,16 +621,50 @@ export class TraqulaFactory extends CoreFactory {
     silent: boolean,
     loc: SourceLocation,
   ): UpdateOperationCreate {
-    return this.updateOperationClearDrop('create', silent, destination, loc);
+    return {
+      type: 'updateOperation',
+      operationType: 'create',
+      silent,
+      destination,
+      loc,
+    };
   }
 
-  private updateOperationAddMoveCopy<T extends 'add' | 'move' | 'copy'>(
-    operationType: T,
+  public updateOperationAddMoveCopy(
+    operationType: 'add',
+    source: GraphRefDefault | GraphRefSpecific,
+    destination: GraphRefDefault | GraphRefSpecific,
+    silent: boolean,
+    loc: SourceLocation,
+  ): UpdateOperationAdd;
+  public updateOperationAddMoveCopy(
+    operationType: 'move',
+    source: GraphRefDefault | GraphRefSpecific,
+    destination: GraphRefDefault | GraphRefSpecific,
+    silent: boolean,
+    loc: SourceLocation,
+  ): UpdateOperationMove ;
+  public updateOperationAddMoveCopy(
+    operationType: 'copy',
+    source: GraphRefDefault | GraphRefSpecific,
+    destination: GraphRefDefault | GraphRefSpecific,
+    silent: boolean,
+    loc: SourceLocation,
+  ): UpdateOperationCopy;
+  public updateOperationAddMoveCopy(
+    operationType: 'add' | 'move' | 'copy',
+    source: GraphRefDefault | GraphRefSpecific,
+    destination: GraphRefDefault | GraphRefSpecific,
+    silent: boolean,
+    loc: SourceLocation,
+  ): UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy;
+  public updateOperationAddMoveCopy(
+    operationType: 'add' | 'move' | 'copy',
     source: GraphRefDefault | GraphRefSpecific,
     destination: GraphRefDefault | GraphRefSpecific,
     silent: boolean,
     loc: SourceLocation,
-  ): Omit<UpdateOperationAdd, 'operationType'> & { operationType: T } {
+  ): UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy {
     return {
       type: 'updateOperation',
       operationType,
@@ -587,39 +702,55 @@ export class TraqulaFactory extends CoreFactory {
     return this.updateOperationAddMoveCopy('copy', source, destination, silent, loc);
   }
 
-  private updateOperationInsertDeleteDelWhere<T extends 'insertdata' | 'deletedata' | 'deletewhere'>(
-    operationType: T,
+  public updateOperationInsDelDataWhere(operationType: 'insertdata', data: Quads[], loc: SourceLocation):
+  UpdateOperationInsertData;
+  public updateOperationInsDelDataWhere(operationType: 'deletedata', data: Quads[], loc: SourceLocation):
+  UpdateOperationDeleteData;
+  public updateOperationInsDelDataWhere(operationType: 'deletewhere', data: Quads[], loc: SourceLocation):
+  UpdateOperationDeleteWhere;
+  public updateOperationInsDelDataWhere(
+    operationType: 'insertdata' | 'deletedata' | 'deletewhere',
     data: Quads[],
     loc: SourceLocation,
-  ): Omit<UpdateOperationInsertData, 'operationType'> & { operationType: T } {
-    return { type: 'updateOperation', operationType, data, loc };
+  ): UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere;
+  public updateOperationInsDelDataWhere(
+    operationType: 'insertdata' | 'deletedata' | 'deletewhere',
+    data: Quads[],
+    loc: SourceLocation,
+  ): UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere {
+    return {
+      type: 'updateOperation',
+      operationType,
+      data,
+      loc,
+    };
   }
 
   public updateOperationInsertData(data: Quads[], loc: SourceLocation): UpdateOperationInsertData {
-    return this.updateOperationInsertDeleteDelWhere('insertdata', data, loc);
+    return this.updateOperationInsDelDataWhere('insertdata', data, loc);
   }
 
   public updateOperationDeleteData(data: Quads[], loc: SourceLocation): UpdateOperationDeleteData {
-    return this.updateOperationInsertDeleteDelWhere('deletedata', data, loc);
+    return this.updateOperationInsDelDataWhere('deletedata', data, loc);
   }
 
   public updateOperationDeleteWhere(data: Quads[], loc: SourceLocation): UpdateOperationDeleteWhere {
-    return this.updateOperationInsertDeleteDelWhere('deletewhere', data, loc);
+    return this.updateOperationInsDelDataWhere('deletewhere', data, loc);
   }
 
   public updateOperationModify(
     loc: SourceLocation,
-    insert: Quads[],
-    del: Quads[],
+    insert: Quads[] | undefined,
+    del: Quads[] | undefined,
     where: Pattern[],
     from: DatasetClauses,
     graph?: TermIri | undefined,
   ): UpdateOperationModify {
     return {
       type: 'updateOperation',
       operationType: 'modify',
-      insert,
-      delete: del,
+      insert: insert ?? [],
+      delete: del ?? [],
       graph,
       where,
       from,