feat: #467 - Wrap ClassExpression.

dsherret · Oct 21, 2018 · 92f4be3 · 92f4be3
1 parent fdb5f42
commit 92f4be3
Show file tree

Hide file tree

Showing 10 changed files with 1,424 additions and 1,325 deletions.
diff --git a/lib/ts-simple-ast.d.ts b/lib/ts-simple-ast.d.ts
diff --git a/src/compiler/ast/CompilerNodeToWrappedType.ts b/src/compiler/ast/CompilerNodeToWrappedType.ts
@@ -6,6 +6,7 @@ export type CompilerNodeToWrappedType<T extends ts.Node> = T extends ts.ArrayBin
     T extends ts.BindingElement ? compiler.BindingElement :
     T extends ts.ObjectBindingPattern ? compiler.ObjectBindingPattern :
     T extends ts.ClassDeclaration ? compiler.ClassDeclaration :
+    T extends ts.ClassExpression ? compiler.ClassExpression :
     T extends ts.ConstructorDeclaration ? compiler.ConstructorDeclaration :
     T extends ts.GetAccessorDeclaration ? compiler.GetAccessorDeclaration :
     T extends ts.MethodDeclaration ? compiler.MethodDeclaration :

diff --git a/src/compiler/ast/class/ClassExpression.ts b/src/compiler/ast/class/ClassExpression.ts
@@ -0,0 +1,7 @@
+import { ts } from "../../../typescript";
+import { ClassLikeDeclarationBase } from "./base";
+import { PrimaryExpression } from "../expression/PrimaryExpression";
+
+export const ClassExpressionBase = ClassLikeDeclarationBase(PrimaryExpression);
+export class ClassExpression extends ClassExpressionBase<ts.ClassExpression> {
+}
diff --git a/src/compiler/ast/class/index.ts b/src/compiler/ast/class/index.ts
@@ -1,5 +1,6 @@
 export * from "./base";
 export * from "./ClassDeclaration";
+export * from "./ClassExpression";
 export * from "./ConstructorDeclaration";
 export * from "./GetAccessorDeclaration";
 export * from "./MethodDeclaration";

diff --git a/src/compiler/ast/kindToNodeMappings.ts b/src/compiler/ast/kindToNodeMappings.ts
@@ -21,6 +21,7 @@ export interface KindToNodeMappings {
     [SyntaxKind.CaseClause]: compiler.CaseClause;
     [SyntaxKind.CatchClause]: compiler.CatchClause;
     [SyntaxKind.ClassDeclaration]: compiler.ClassDeclaration;
+    [SyntaxKind.ClassExpression]: compiler.ClassExpression;
     [SyntaxKind.Constructor]: compiler.ConstructorDeclaration;
     [SyntaxKind.ConstructorType]: compiler.ConstructorTypeNode;
     [SyntaxKind.ConstructSignature]: compiler.ConstructSignatureDeclaration;
@@ -175,6 +176,7 @@ export interface KindToExpressionMappings {
     [SyntaxKind.AwaitExpression]: compiler.AwaitExpression;
     [SyntaxKind.BinaryExpression]: compiler.BinaryExpression;
     [SyntaxKind.CallExpression]: compiler.CallExpression;
+    [SyntaxKind.ClassExpression]: compiler.ClassExpression;
     [SyntaxKind.CommaListExpression]: compiler.CommaListExpression;
     [SyntaxKind.ConditionalExpression]: compiler.ConditionalExpression;
     [SyntaxKind.DeleteExpression]: compiler.DeleteExpression;

diff --git a/src/factories/kindToWrapperMappings.ts b/src/factories/kindToWrapperMappings.ts
@@ -23,6 +23,7 @@ export const kindToWrapperMappings: { [key: number]: any } = {
     [SyntaxKind.CaseClause]: compiler.CaseClause,
     [SyntaxKind.CatchClause]: compiler.CatchClause,
     [SyntaxKind.ClassDeclaration]: compiler.ClassDeclaration,
+    [SyntaxKind.ClassExpression]: compiler.ClassExpression,
     [SyntaxKind.Constructor]: compiler.ConstructorDeclaration,
     [SyntaxKind.ConstructorType]: compiler.ConstructorTypeNode,
     [SyntaxKind.ConstructSignature]: compiler.ConstructSignatureDeclaration,

diff --git a/src/tests/compiler/class/base/classDeclarationBaseTests.ts b/src/tests/compiler/class/base/classDeclarationBaseTests.ts
diff --git a/src/tests/compiler/class/classDeclarationTests.ts b/src/tests/compiler/class/classDeclarationTests.ts
diff --git a/src/utils/TypeGuards.ts b/src/utils/TypeGuards.ts
@@ -55,6 +55,7 @@ export class TypeGuards {
     static isAbstractableNode(node: compiler.Node): node is compiler.AbstractableNode & compiler.AbstractableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.PropertyDeclaration:
@@ -370,6 +371,28 @@ export class TypeGuards {
         return node.getKind() === SyntaxKind.ClassDeclaration;
     }
 
+    /**
+     * Gets if the node is a ClassExpression.
+     * @param node - Node to check.
+     */
+    static isClassExpression(node: compiler.Node): node is compiler.ClassExpression {
+        return node.getKind() === SyntaxKind.ClassExpression;
+    }
+
+    /**
+     * Gets if the node is a ClassLikeDeclarationBase.
+     * @param node - Node to check.
+     */
+    static isClassLikeDeclarationBase(node: compiler.Node): node is compiler.ClassLikeDeclarationBase & compiler.ClassLikeDeclarationBaseExtensionType {
+        switch (node.getKind()) {
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
+                return true;
+            default:
+                return false;
+        }
+    }
+
     /**
      * Gets if the node is a CommaListExpression.
      * @param node - Node to check.
@@ -449,6 +472,7 @@ export class TypeGuards {
     static isDecoratableNode(node: compiler.Node): node is compiler.DecoratableNode & compiler.DecoratableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.PropertyDeclaration:
@@ -595,6 +619,7 @@ export class TypeGuards {
             case SyntaxKind.StringKeyword:
             case SyntaxKind.SymbolKeyword:
             case SyntaxKind.UndefinedKeyword:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Identifier:
             case SyntaxKind.AsExpression:
             case SyntaxKind.AwaitExpression:
@@ -825,6 +850,7 @@ export class TypeGuards {
     static isHeritageClauseableNode(node: compiler.Node): node is compiler.HeritageClauseableNode & compiler.HeritageClauseableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.InterfaceDeclaration:
                 return true;
             default:
@@ -853,7 +879,13 @@ export class TypeGuards {
      * @param node - Node to check.
      */
     static isImplementsClauseableNode(node: compiler.Node): node is compiler.ImplementsClauseableNode & compiler.ImplementsClauseableNodeExtensionType {
-        return node.getKind() === SyntaxKind.ClassDeclaration;
+        switch (node.getKind()) {
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
+                return true;
+            default:
+                return false;
+        }
     }
 
     /**
@@ -1114,6 +1146,7 @@ export class TypeGuards {
     static isJSDocableNode(node: compiler.Node): node is compiler.JSDocableNode & compiler.JSDocableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Constructor:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
@@ -1273,6 +1306,7 @@ export class TypeGuards {
      */
     static isLeftHandSideExpression(node: compiler.Node): node is compiler.LeftHandSideExpression {
         switch (node.getKind()) {
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Identifier:
             case SyntaxKind.CallExpression:
             case SyntaxKind.ElementAccessExpression:
@@ -1370,6 +1404,7 @@ export class TypeGuards {
      */
     static isMemberExpression(node: compiler.Node): node is compiler.MemberExpression {
         switch (node.getKind()) {
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Identifier:
             case SyntaxKind.ElementAccessExpression:
             case SyntaxKind.ImportKeyword:
@@ -1430,6 +1465,7 @@ export class TypeGuards {
     static isModifierableNode(node: compiler.Node): node is compiler.ModifierableNode & compiler.ModifierableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Constructor:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
@@ -1475,6 +1511,7 @@ export class TypeGuards {
     static isNameableNode(node: compiler.Node): node is compiler.NameableNode & compiler.NameableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.FunctionDeclaration:
             case SyntaxKind.FunctionExpression:
                 return true;
@@ -1728,6 +1765,7 @@ export class TypeGuards {
      */
     static isPrimaryExpression(node: compiler.Node): node is compiler.PrimaryExpression {
         switch (node.getKind()) {
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Identifier:
             case SyntaxKind.ImportKeyword:
             case SyntaxKind.MetaProperty:
@@ -1856,6 +1894,7 @@ export class TypeGuards {
         switch (node.getKind()) {
             case SyntaxKind.BindingElement:
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.PropertyDeclaration:
@@ -1901,6 +1940,7 @@ export class TypeGuards {
         switch (node.getKind()) {
             case SyntaxKind.BindingElement:
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.PropertyDeclaration:
@@ -2246,6 +2286,7 @@ export class TypeGuards {
     static isTextInsertableNode(node: compiler.Node): node is compiler.TextInsertableNode & compiler.TextInsertableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Constructor:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
@@ -2425,6 +2466,7 @@ export class TypeGuards {
     static isTypeParameteredNode(node: compiler.Node): node is compiler.TypeParameteredNode & compiler.TypeParameteredNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Constructor:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.MethodDeclaration:
@@ -2477,6 +2519,7 @@ export class TypeGuards {
      */
     static isUnaryExpression(node: compiler.Node): node is compiler.UnaryExpression {
         switch (node.getKind()) {
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Identifier:
             case SyntaxKind.AwaitExpression:
             case SyntaxKind.CallExpression:
@@ -2568,6 +2611,7 @@ export class TypeGuards {
      */
     static isUpdateExpression(node: compiler.Node): node is compiler.UpdateExpression {
         switch (node.getKind()) {
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.Identifier:
             case SyntaxKind.CallExpression:
             case SyntaxKind.ElementAccessExpression:

diff --git a/wrapped-nodes.md b/wrapped-nodes.md
@@ -6,7 +6,7 @@ The disadvantage to a node not being wrapped is that it won't have helper method
 
 ## Exist
 
-**Total:** 163
+**Total:** 164
 
 * [ArrayBindingPattern](src/compiler/ast/binding/ArrayBindingPattern.ts)
     * :heavy_check_mark: elements
@@ -57,6 +57,7 @@ The disadvantage to a node not being wrapped is that it won't have helper method
     * :heavy_check_mark: block
 * [ClassDeclaration](src/compiler/ast/class/ClassDeclaration.ts)
     * :heavy_check_mark: name
+* [ClassExpression](src/compiler/ast/class/ClassExpression.ts)
 * [CommaListExpression](src/compiler/ast/expression/CommaListExpression.ts)
     * :heavy_check_mark: elements
 * [ComputedPropertyName](src/compiler/ast/common/ComputedPropertyName.ts)
@@ -413,11 +414,10 @@ The disadvantage to a node not being wrapped is that it won't have helper method
 
 ## Not Exist
 
-**Total:** 58
+**Total:** 57
 
 * Bundle
 * ClassElement
-* ClassExpression
 * ClassLikeDeclarationBase
 * ConditionalTypeNode
 * DeclarationStatement