feat: traits, initial implementation (#46)

* trait impl

* use traits for References

* checkpoint

* use Self reference in Reference impl

Author: menduz

src/compiler/nodes.ts

@@ -143,9 +143,8 @@ export namespace Nodes {
   export abstract class ExpressionNode extends Node {}
 
   export class NameIdentifierNode extends Node {
+    impls = new Set<ImplDirective>();
     internalIdentifier?: string;
-    namespaceNames?: Map<string, NameIdentifierNode>;
-    parentNamespace?: NameIdentifierNode;
 
     get childrenOrEmpty(): Node[] {
       return [];
@@ -489,16 +488,25 @@ export namespace Nodes {
   }
 
   export class ImplDirective extends DirectiveNode {
+    baseImpl?: ReferenceNode;
+    selfTypeName?: NameIdentifierNode;
+    readonly namespaceNames: Map<string, NameIdentifierNode> = new Map();
+
     constructor(
       astNode: ASTNode,
-      public readonly reference: ReferenceNode,
+      public readonly targetImpl: ReferenceNode,
       public readonly directives: DirectiveNode[]
     ) {
       super(astNode);
     }
 
     get childrenOrEmpty() {
-      return [...(this.decorators || []), this.reference, ...(this.directives || [])];
+      return [
+        ...(this.decorators || []),
+        this.targetImpl,
+        ...(this.baseImpl ? [this.baseImpl] : []),
+        ...(this.directives || [])
+      ];
     }
   }
 
@@ -593,6 +601,19 @@ export namespace Nodes {
     }
   }
 
+  export class TraitDirectiveNode extends DirectiveNode {
+    readonly namespaceNames: Map<string, NameIdentifierNode> = new Map();
+    selfTypeName?: NameIdentifierNode;
+
+    constructor(astNode: ASTNode, public readonly traitName: NameIdentifierNode, public directives: DirectiveNode[]) {
+      super(astNode);
+    }
+
+    get childrenOrEmpty() {
+      return [...(this.decorators || []), this.traitName, ...this.directives];
+    }
+  }
+
   export class EnumDirectiveNode extends DirectiveNode {
     constructor(
       astNode: ASTNode,

src/compiler/phases/canonicalPhase.ts

@@ -112,7 +112,10 @@ const visitor = {
     return ret;
   },
   ImplDirective(astNode: Nodes.ASTNode) {
-    const reference = visit(findChildrenTypeOrFail(astNode, 'Reference'));
+    const references = astNode.children.filter($ => $.type === 'Reference');
+
+    // the last Reference is the target
+    const target = visit(references.pop()!);
 
     const directivesNode = findChildrenType(astNode, 'NamespaceElementList');
 
@@ -121,7 +124,11 @@ const visitor = {
       : [];
     // TODO: warn
 
-    const ret = new Nodes.ImplDirective(astNode, reference, directives);
+    const ret = new Nodes.ImplDirective(astNode, target, directives);
+
+    if (references.length) {
+      ret.baseImpl = visit(references.pop()!);
+    }
 
     ret.isPublic = !findChildrenType(astNode, 'PrivateModifier');
 
@@ -199,6 +206,8 @@ const visitor = {
 
     const variableName = visit(child);
 
+    console.assert(!!variableName, 'missing variable name');
+
     const ret = new Nodes.TypeDirectiveNode(astNode, variableName);
 
     ret.isPublic = isPublic;
@@ -230,6 +239,34 @@ const visitor = {
 
     return ret;
   },
+  TraitDirective(astNode: Nodes.ASTNode) {
+    const children = astNode.children.slice();
+
+    let child = children.shift()!;
+    let isPublic = true;
+
+    if (child.type === 'PrivateModifier') {
+      isPublic = false;
+      child = children.shift()!;
+    }
+
+    const variableName = visit(child);
+
+    const typeDeclElements = findChildrenType(astNode, 'TraitDeclElements');
+
+    const declarations = typeDeclElements ? typeDeclElements.children.map($ => visit($)) : [];
+
+    declarations.forEach($ => {
+      if ($ instanceof Nodes.FunDirectiveNode && !$.functionNode.body) {
+        $.functionNode.annotate(new annotations.SignatureDeclaration());
+      }
+    });
+
+    const ret = new Nodes.TraitDirectiveNode(astNode, variableName, declarations);
+    ret.isPublic = isPublic;
+
+    return ret;
+  },
   FunDeclaration(astNode: Nodes.ASTNode) {
     const functionName = visit(
       findChildrenTypeOrFail(astNode, 'FunctionName', 'A function name is required').children[0]
@@ -251,7 +288,12 @@ const visitor = {
     }
 
     fun.parameters = params.children.map($ => visit($));
-    fun.body = visitLastChild(astNode);
+
+    const body = findChildrenType(astNode, 'FunAssignExpression');
+
+    if (body) {
+      fun.body = visitLastChild(body);
+    }
 
     return fun;
   },