#63 allow abstract classes to be marked as @ASTNode

Author: alessiostalla

src/interop/ecore.ts

@@ -327,7 +327,7 @@ export function fromEObject(obj: ECore.EObject | any, parent?: Node): ASTElement
         return fromEObject(obj.get("position")) as Position;
     }
     const ePackage = eClass.eContainer as ECore.EPackage;
-    const constructor = NODE_TYPES[ePackage.get("name")]?.nodes[eClass.get("name")];
+    const constructor = NODE_TYPES[ePackage.get("name")]?.nodes[eClass.get("name")] as new (...args: any[]) => Node;
     if(constructor) {
         const node = new constructor().withParent(parent);
         node.parent = parent;

src/model/model.ts

@@ -6,7 +6,7 @@ export const NODE_DEFINITION_SYMBOL = Symbol("nodeDefinition");
 
 export type PackageDescription = {
     name: string,
-    nodes: { [name: string]: new (...args: any[]) => Node }
+    nodes: { [name: string]: abstract new (...args: any[]) => Node }
 };
 export const NODE_TYPES: { [name: string]: PackageDescription } = {
     "": { name: "", nodes: {} }
@@ -29,7 +29,7 @@ export type PropertyDefinition = {
     arrayType?: any
 }
 
-export function getNodeDefinition(node: Node | (new (...args: any[]) => Node)): NodeDefinition {
+export function getNodeDefinition(node: Node | (abstract new (...args: any[]) => Node)): NodeDefinition {
     const target = typeof node === "function" ? node : node.constructor;
     let definition: NodeDefinition;
     if(Object.prototype.hasOwnProperty.call(target, NODE_DEFINITION_SYMBOL)) {
@@ -378,12 +378,14 @@ export function ensurePackage(packageName: string): PackageDescription {
 }
 
 export function errorOnRedefinition<T>(
-    name: string, target: { new(...args: any[]): T }, existingTarget: { new(...args: any[]): Node }): void {
+    name: string, target: abstract new(...args: any[]) => T, existingTarget: abstract new(...args: any[]) => Node
+): void {
     throw new Error(`${name} (${target}) is already defined as ${existingTarget}`);
 }
 
 export function warnOnRedefinition<T>(
-    name: string, target: { new(...args: any[]): T }, existingTarget: { new(...args: any[]): Node }): void {
+    name: string, target: abstract new(...args: any[]) => T , existingTarget: abstract new(...args: any[]) => Node
+): void {
     console.warn(`Redefining ${name} from`, existingTarget, 'to', target);
 }
 
@@ -394,7 +396,7 @@ export function setNodeRedefinitionStrategy(strategy: typeof errorOnRedefinition
 }
 
 export function registerNodeDefinition<T extends Node>(
-    target: { new(...args: any[]): T }, pkg?: string, name?: string): NodeDefinition {
+    target: abstract new (...args: any[]) => T, pkg?: string, name?: string): NodeDefinition {
     let def: NodeDefinition;
     if(pkg !== undefined) {
         if (!name) {
@@ -484,7 +486,7 @@ export function registerNodeReference<T extends Node & PossiblyNamed>(
 //------------//
 
 export function ASTNode<T extends Node>(pkg: string, name: string) {
-    return function (target: new (...args: any[]) => T): void {
+    return function (target: abstract new (...args: any[]) => T): void {
         registerNodeDefinition(target, pkg, name);
     };
 }

tests/ecore.test.ts

@@ -247,11 +247,11 @@ export class CompilationUnit extends Node {
 \t@Child()
 \tstatements;
 }`);
-                let node = new NODE_TYPES["SimpleMM"].nodes["CompilationUnit"]() as any;
-                expect(node instanceof Node).to.be.true;
+                let node = new (NODE_TYPES["SimpleMM"].nodes["CompilationUnit"] as any)();
+                expect(node).to.be.instanceof(Node);
                 expect(node.constructor[SYMBOL_NODE_NAME]).to.equal("CompilationUnit");
-                node = new NODE_TYPES["SimpleMM"].nodes["Statement"]() as any;
-                expect(node instanceof Node).to.be.true;
+                node = new (NODE_TYPES["SimpleMM"].nodes["Statement"] as any)();
+                expect(node).to.be.instanceof(Node);
                 expect(node.constructor[SYMBOL_NODE_NAME]).to.equal("Statement");
                 //Subclassing
                 expect(NODE_TYPES["SimpleMM"].nodes["StringLiteral"][SYMBOL_CLASS_DEFINITION]).to.equal(
@@ -260,10 +260,10 @@ export class StringLiteral extends Expression {
 \t@Attribute()
 \tvalue;
 }`);
-                node = new NODE_TYPES["SimpleMM"].nodes["StringLiteral"]() as any;
-                expect(node instanceof NODE_TYPES["SimpleMM"].nodes["Expression"]).to.be.true;
-                expect(node instanceof NODE_TYPES["SimpleMM"].nodes["StringLiteral"]).to.be.true;
-                expect(node instanceof NODE_TYPES["SimpleMM"].nodes["CompilationUnit"]).to.be.false;
+                node = new (NODE_TYPES["SimpleMM"].nodes["StringLiteral"] as any)();
+                expect(node).to.be.instanceof(NODE_TYPES["SimpleMM"].nodes["Expression"]);
+                expect(node).to.be.instanceof(NODE_TYPES["SimpleMM"].nodes["StringLiteral"]);
+                expect(node).not.to.be.instanceof(NODE_TYPES["SimpleMM"].nodes["CompilationUnit"]);
                 expect(node.constructor[SYMBOL_NODE_NAME]).to.equal("StringLiteral");
 
                 expect(NODE_TYPES[""].nodes["CompilationUnit"]).to.be.undefined;