introduction of localized type as a split between Node types and loc anotatio

Author: jitsedesmet

packages/core/lib/CoreFactory.ts

@@ -8,21 +8,32 @@ import type {
   SourceLocationSource,
   SourceLocationStringReplace,
   Node,
+  Localized,
+  Wrap,
 } from './nodeTypings';
 
 export class CoreFactory {
-  public sourceLocation(...elements: (Pick<IToken, 'startOffset' | 'endOffset'> | SourceLocation)[]): SourceLocation {
-    const filtered =
-      elements.filter(element => !this.isSourceLocation(element) || this.isSourceLocationSource(element));
+  public wrap<T>(val: T, loc: SourceLocation): Wrap<T> {
+    return { val, loc };
+  }
+
+  public isLocalized(obj: unknown): obj is Localized {
+    return typeof obj === 'object' && obj !== null && 'loc' in obj &&
+      typeof obj.loc === 'object' && obj.loc !== null && 'sourceLocationType' in obj;
+  }
+
+  public sourceLocation(...elements: (undefined | IToken | Localized)[]): SourceLocation {
+    const filtered = <(Localized | IToken)[]> elements.filter(element =>
+      element && (!this.isLocalized(element) || this.isSourceLocationSource(element.loc)));
     if (filtered.length === 0) {
       return this.sourceLocationNoMaterialize();
     }
     const first = filtered[0];
     const last = filtered.at(-1)!;
     return {
       sourceLocationType: 'source',
-      start: this.isSourceLocationSource(first) ? first.start : first.startOffset,
-      end: this.isSourceLocationSource(last) ? last.end : (last.endOffset! + 1),
+      start: this.isLocalized(first) ? (<SourceLocationSource> first.loc).start : first.startOffset,
+      end: this.isLocalized(last) ? (<SourceLocationSource> last.loc).end : (last.endOffset! + 1),
     };
   }
 
@@ -73,12 +84,12 @@ export class CoreFactory {
     return this.isSourceLocation(loc) && loc.sourceLocationType === 'autoGenerate';
   }
 
-  public nodeShouldPrint(node: Node): boolean {
+  public nodeShouldPrint(node: Localized): boolean {
     return this.isSourceLocationNodeReplace(node.loc) ||
       this.isSourceLocationNodeAutoGenerate(node.loc);
   }
 
-  public printFilter(node: Node, callback: () => void): void {
+  public printFilter(node: Localized, callback: () => void): void {
     if (this.nodeShouldPrint(node)) {
       callback();
     }

packages/core/lib/generator-builder/generatorTypes.ts

@@ -1,4 +1,4 @@
-import type { Node } from '../nodeTypings';
+import type { Localized } from '../nodeTypings';
 
 /**
  * Type used to declare generator rules.
@@ -18,7 +18,7 @@ export type GeneratorRule<
    * Generation happens on a per AST node basis.
    * The core will implement the generation as such. If this ever changes, we will cross that bridge when we get there.
    */
-  ReturnType = any,
+  ReturnType extends Localized = Localized,
   /**
    * Function arguments that can be given to convey the state of the current parse operation.
    */
@@ -30,7 +30,7 @@ export type GeneratorRule<
 };
 
 export interface RuleDefArg {
-  SUBRULE: <T extends Node, U>(cstDef: GeneratorRule<any, string, T, U>, input: T, arg: U) => void;
+  SUBRULE: <T extends Localized, U>(cstDef: GeneratorRule<any, string, T, U>, input: T, arg: U) => void;
   PRINT: (...args: string[]) => void;
   PRINT_WORD: (...args: string[]) => void;
   CATCHUP: (until: number) => void;

packages/core/lib/nodeTypings.ts

@@ -1,15 +1,22 @@
-/**
- * A AST node. Nodes are indexable by their types.
- * When generating, the SUBRULES called should be located within the current location range.
- */
-export type Node = {
-  type: string;
+export interface Localized {
   /**
    * Location undefined means the node does have a string representation, but it was not clarified.
    * This happens when an AST node is patched by a client of the lib.
    */
   loc: SourceLocation;
-};
+}
+
+export interface Wrap<T> extends Localized {
+  val: T;
+}
+
+/**
+ * A AST node. Nodes are indexable by their types.
+ * When generating, the SUBRULES called should be located within the current location range.
+ */
+export interface Node extends Localized {
+  type: string;
+}
 
 export interface SourceLocationBase {
   sourceLocationType: string;

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

@@ -1,6 +1,4 @@
-import type { Node } from '@traqula/core';
-
-export type Wrap<T> = { val: T } & Node['loc'];
+import type { Localized, Node } from '@traqula/core';
 
 export type GraphRefBase = Node & {
   type: 'graphRef';
@@ -202,7 +200,7 @@ export type PatternGraph = PatternBase & {
 };
 export type PatternUnion = PatternBase & {
   patternType: 'union';
-  patterns: Pattern[];
+  patterns: PatternGroup[];
 };
 export type BasicGraphPattern = (TripleNesting | TripleCollection)[];
 export type PatternBgp = PatternBase & {
@@ -267,7 +265,7 @@ export type SolutionModifierHaving = SolutionModifierBase & {
 };
 export type Ordering =
   | Expression
-  | ({ descending: boolean; expression: Expression } & Pick<Node, 'loc'>);
+  | (Localized & { descending: boolean; expression: Expression });
 export type SolutionModifierOrder = SolutionModifierBase & {
   modifierType: 'order';
   orderDefs: Ordering[];

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

@@ -1,4 +1,4 @@
-import type { GeneratorRule, ParserRule } from '@traqula/core';
+import type { GeneratorRule, ParserRule, Localized } from '@traqula/core';
 import type { TraqulaFactory } from './factory';
 
 export type SparqlRule<
@@ -10,8 +10,8 @@ export type SparqlRule<
    * Type that will be returned after a correct parse of this rule.
    * This type will be the return type of calling SUBRULE with this grammar rule.
    */
-  ReturnType = unknown,
-  GenInputType = ReturnType,
+  ReturnType extends Localized = Localized,
+  GenInputType extends Localized = ReturnType,
   /**
    * Function arguments that can be given to convey the state of the current parse operation.
    */
@@ -28,7 +28,7 @@ export type SparqlGeneratorRule<
    * Type that will be returned after a correct parse of this rule.
    * This type will be the return type of calling SUBRULE with this grammar rule.
    */
-  ReturnType = unknown,
+  ReturnType extends Localized = Localized,
   /**
    * Function arguments that can be given to convey the state of the current parse operation.
    */

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

@@ -54,6 +54,7 @@ import type {
   TermLiteralStr,
   TermLiteralTyped,
   TermVariable,
+  TripleCollection,
   TripleCollectionBlankNodeProperties,
   TripleCollectionList,
   TripleNesting,
@@ -234,14 +235,18 @@ export class TraqulaFactory extends CoreFactory {
       subject,
       predicate,
       object,
-      loc: loc ?? this.sourceLocation(subject.loc, predicate.loc, object.loc),
+      loc: loc ?? this.sourceLocation(subject, predicate, object),
     };
   }
 
   public isPatternGroup(x: Pattern): x is PatternGroup {
     return x.type === 'pattern' && x.patternType === 'group';
   }
 
+  public isPatternUnion(x: Pattern): x is PatternUnion {
+    return x.type === 'pattern' && x.patternType === 'union';
+  }
+
   public isPattern(x: any): x is Pattern {
     return x.type === 'pattern';
   }
@@ -293,7 +298,7 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
-  public patternUnion(patterns: Pattern[], loc: SourceLocation): PatternUnion {
+  public patternUnion(patterns: PatternGroup[], loc: SourceLocation): PatternUnion {
     return {
       type: 'pattern',
       patternType: 'union',
@@ -360,13 +365,6 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
-  public deGroupSingle(group: PatternGroup & Pattern): Pattern {
-    if (group.patterns.length === 1) {
-      return group.patterns[0];
-    }
-    return group;
-  }
-
   public aggregate(
     aggregation: string,
     distinct: boolean,
@@ -556,6 +554,10 @@ export class TraqulaFactory extends CoreFactory {
     };
   }
 
+  public isTripleCollection(collection: object): collection is TripleCollection {
+    return 'type' in collection && collection.type === 'tripleCollection';
+  }
+
   public resetBlankNodeCounter(): void {
     this.blankNodeCounter = 0;
   }

packages/rules-sparql-1-1/lib/grammar/dataSetClause.ts

@@ -1,7 +1,7 @@
-import type { RuleDefReturn } from '@traqula/core';
+import type { RuleDefReturn, Wrap } from '@traqula/core';
 import type { TokenType } from 'chevrotain';
 import * as l from '../lexer';
-import type { DatasetClauses, TermIri, Wrap } from '../RoundTripTypes';
+import type { DatasetClauses, TermIri } from '../RoundTripTypes';
 import type { SparqlGrammarRule, SparqlRule } from '../Sparql11types';
 import { iri } from './literals';
 
@@ -16,17 +16,12 @@ export function datasetClauseUsing<RuleName extends 'usingClause' | 'datasetClau
       return OR<RuleDefReturn<typeof datasetClause>>([
         { ALT: () => {
           const iri = SUBRULE(defaultGraphClause, undefined);
-          return ACTION(() => ({
-            val: { named: false, value: iri },
-            ...C.factory.sourceLocation(start, iri.loc),
-          }));
+          return ACTION(() => C.factory.wrap({ named: false, value: iri }, C.factory.sourceLocation(start, iri)));
         } },
         { ALT: () => {
           const namedClause = SUBRULE(namedGraphClause, undefined);
-          return ACTION(() => ({
-            val: { named: true, value: namedClause.val },
-            ...C.factory.sourceLocation(start, namedClause),
-          }));
+          return ACTION(() =>
+            C.factory.wrap({ named: true, value: namedClause.val }, C.factory.sourceLocation(start, namedClause)));
         } },
       ]);
     },
@@ -98,7 +93,7 @@ export const namedGraphClause: SparqlGrammarRule<'namedGraphClause', Wrap<TermIr
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const named = CONSUME(l.graph.named);
     const iri = SUBRULE(sourceSelector, undefined);
-    return ACTION(() => ({ val: iri, ...C.factory.sourceLocation(named, iri.loc) }));
+    return ACTION(() => C.factory.wrap(iri, C.factory.sourceLocation(named, iri)));
   },
 };