#62 ParseTreeASTTransformer: propagate the Source as in Kolasu

Author: alessiostalla

CHANGELOG.md

@@ -2,6 +2,14 @@
 All notable changes to this project from version 1.2.0 upwards are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.6.19] – Not yet released
+
+### Added
+- ParseTreeToASTTransformer: propagate the Source as in Kolasu
+
+### Changed
+- Updated to antlr4ng 3
+
 ## [1.6.18] – 2024-03-21
 
 ### Fixed

src/mapping.ts

@@ -2,6 +2,8 @@ import {ParserRuleContext, TerminalNode} from "antlr4ng";
 import {Node, Origin} from "./model/model";
 import {ASTTransformer} from "./transformation/transformation";
 import {ParseTreeOrigin} from "./parsing";
+import {Issue} from "./validation";
+import {Source} from "./model/position";
 
 
 /**
@@ -10,6 +12,10 @@ import {ParseTreeOrigin} from "./parsing";
  */
 export class ParseTreeToASTTransformer extends ASTTransformer {
 
+    constructor(issues: Issue[] = [], allowGenericNode = true, public readonly source?: Source) {
+        super(issues, allowGenericNode);
+    }
+
     /**
      * Performs the transformation of a node and, recursively, its descendants. In addition to the overridden method,
      * it also assigns the parseTreeNode to the AST node so that it can keep track of its position.
@@ -39,4 +45,23 @@ export class ParseTreeToASTTransformer extends ASTTransformer {
             return undefined;
         }
     }
+
+    /**
+     * Performs the transformation of a node and, recursively, its descendants. In addition to the overridden method,
+     * it also assigns the parseTreeNode to the AST node so that it can keep track of its position.
+     * However, a node factory can override the parseTreeNode of the nodes it creates (but not the parent).
+     */
+    transformIntoNodes(source?: any, parent?: Node) {
+        const transformed = super.transformIntoNodes(source, parent);
+        return transformed.map((node) => {
+            if (source instanceof ParserRuleContext) {
+                if (node.origin == null) {
+                    node.withParseTreeNode(source, this.source);
+                } else if (node.position != null && node.source == null) {
+                    node.position.source = this.source;
+                }
+            }
+            return node;
+        });
+    }
 }

src/model/model.ts

@@ -1,4 +1,4 @@
-import {Position} from "./position";
+import {Position, Source} from "./position";
 import "reflect-metadata";
 import {PossiblyNamed, ReferenceByName} from "./naming";
 
@@ -90,6 +90,10 @@ export abstract class Origin {
     overlaps(position?: Position): boolean {
         return this.position?.overlaps(position) || false
     }
+
+    get source(): Source | undefined {
+        return this.position?.source;
+    }
 }
 
 export class SimpleOrigin extends Origin {

src/model/position.ts

@@ -50,8 +50,8 @@ export class Point {
         return other && this.compareTo(other) <= 0;
     }
 
-    asPosition(): Position {
-        return new Position(this, this);
+    asPosition(source?: Source): Position {
+        return new Position(this, this, source);
     }
 }
 

src/parsing/parse-tree.ts

@@ -1,4 +1,4 @@
-import {Node, Origin, Point, Position} from "../";
+import {Node, Origin, Point, Position, Source} from "../";
 import {ParserRuleContext, ParseTree, TerminalNode, Token} from "antlr4ng";
 
 // Note: we cannot provide Kolasu-style extension methods on ParseTree because it's an interface.
@@ -12,27 +12,27 @@ declare module "../model/position" {
     }
     // eslint-disable-next-line @typescript-eslint/no-namespace
     export namespace Position {
-        export function ofParseTree(parseTree: ParseTree): Position | undefined;
+        export function ofParseTree(parseTree: ParseTree, source?: Source): Position | undefined;
         export function ofToken(token: Token): Position;
         export function ofTokenStart(token: Token): Position;
         export function ofTokenEnd(token: Token): Position;
     }
 }
 
-export function positionOfParseTree(parseTree: ParseTree): Position | undefined {
+export function positionOfParseTree(parseTree: ParseTree, source?: Source): Position | undefined {
     if(parseTree instanceof ParserRuleContext) {
         const startToken = parseTree.start;
         const stopToken = parseTree.stop;
 
         if (startToken) {
             if (stopToken) {
-                return new Position(Point.ofTokenStart(startToken), Point.ofTokenEnd(stopToken));
+                return new Position(Point.ofTokenStart(startToken), Point.ofTokenEnd(stopToken), source);
             } else {
-                return Point.ofTokenStart(startToken).asPosition();
+                return Point.ofTokenStart(startToken).asPosition(source);
             }
         }
     } else if(parseTree instanceof TerminalNode) {
-        return new Position(Point.ofTokenStart(parseTree.symbol), Point.ofTokenEnd(parseTree.symbol));
+        return new Position(Point.ofTokenStart(parseTree.symbol), Point.ofTokenEnd(parseTree.symbol), source);
     }
 }
 
@@ -60,12 +60,12 @@ Position.ofToken = function (token: Token): Position {
 }
 
 export class ParseTreeOrigin extends Origin {
-    constructor(public parseTree?: ParseTree) {
+    constructor(public parseTree?: ParseTree, protected readonly _source?: Source) {
         super();
     }
 
     get position(): Position | undefined {
-        return this.parseTree ? Position.ofParseTree(this.parseTree) : undefined;
+        return this.parseTree ? Position.ofParseTree(this.parseTree, this._source) : undefined;
     }
 
     get sourceText(): string | undefined {
@@ -77,12 +77,17 @@ export class ParseTreeOrigin extends Origin {
             return undefined;
         }
     }
+
+
+    get source(): Source | undefined {
+        return this._source;
+    }
 }
 
 declare module '../model/model' {
     export interface Node {
         parseTree?: ParseTree;
-        withParseTreeNode(parseTree?: ParseTree | null): this;
+        withParseTreeNode(parseTree?: ParseTree | null, source?: Source): this;
     }
 }
 
@@ -92,15 +97,15 @@ declare module 'antlr4ng' {
     }
 }
 
-export function withParseTreeNode(node: Node, parseTree?: ParseTree | null): Node {
+export function withParseTreeNode(node: Node, parseTree?: ParseTree | null, source?: Source): Node {
     if (parseTree) {
-        node.origin = new ParseTreeOrigin(parseTree);
+        node.origin = new ParseTreeOrigin(parseTree, source);
     }
     return node;
 }
 
-Node.prototype.withParseTreeNode = function (parseTree) {
-    return withParseTreeNode(this, parseTree);
+Node.prototype.withParseTreeNode = function (parseTree, source) {
+    return withParseTreeNode(this, parseTree, source);
 }
 
 Object.defineProperty(Node.prototype, "parseTree", {