Merge branch 'master' into typed-rest-element

Author: JamesHenry

src/convert.ts

@@ -140,33 +140,39 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
   }
 
   /**
-   * Coverts body ExpressionStatements to directives
+   * Coverts body Nodes and add directive field to StringLiterals
+   * @param {ts.NodeArray<ts.Statement>} nodes of ts.Node
+   * @returns {ESTreeNode[]} Array of body statements
    */
-  function convertBodyExpressionsToDirectives() {
-    if (result.body && nodeUtils.canContainDirective(node)) {
-      const unique: string[] = [];
-
-      // directives has to be unique, if directive is registered twice pick only first one
-      result.body
-        .filter(
-          (child: ESTreeNode) =>
-            child.type === AST_NODE_TYPES.ExpressionStatement &&
+  function convertBodyExpressions(
+    nodes: ts.NodeArray<ts.Statement>
+  ): ESTreeNode[] {
+    // directives has to be unique, if directive is registered twice pick only first one
+    const unique: string[] = [];
+    const allowDirectives = nodeUtils.canContainDirective(node);
+
+    return (
+      nodes
+        .map(statement => {
+          const child = convertChild(statement);
+          if (
+            allowDirectives &&
+            child &&
             child.expression &&
-            child.expression.type === AST_NODE_TYPES.Literal &&
-            (child.expression as any).value &&
-            typeof (child.expression as any).value === 'string' &&
-            // ignore parenthesized expressions
-            ast.text.charAt(child.range[0]) !== '('
-        )
-        .forEach(
-          (child: { directive: string; expression: { raw: string } }) => {
-            if (!unique.includes((child.expression as any).raw)) {
-              child.directive = child.expression.raw.slice(1, -1);
-              unique.push(child.expression.raw);
+            ts.isExpressionStatement(statement) &&
+            ts.isStringLiteral(statement.expression)
+          ) {
+            const raw = child.expression.raw!;
+            if (!unique.includes(raw)) {
+              child.directive = raw.slice(1, -1);
+              unique.push(raw);
             }
           }
-        );
-    }
+          return child!; // child can be null but it's filtered below
+        })
+        // filter out unknown nodes for now
+        .filter(statement => statement)
+    );
   }
 
   /**
@@ -244,45 +250,22 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
   }
 
   /**
-   * Converts a child into a class implements node. This creates an intermediary
-   * ClassImplements node to match what Flow does.
-   * @param {ts.ExpressionWithTypeArguments} child The TypeScript AST node to convert.
-   * @returns {ESTreeNode} The type annotation node.
-   */
-  function convertClassImplements(
-    child: ts.ExpressionWithTypeArguments
-  ): ESTreeNode {
-    const id = convertChild(child.expression) as ESTreeNode;
-    const classImplementsNode: ESTreeNode = {
-      type: AST_NODE_TYPES.ClassImplements,
-      loc: id.loc,
-      range: id.range,
-      id
-    };
-    if (child.typeArguments && child.typeArguments.length) {
-      classImplementsNode.typeParameters = convertTypeArgumentsToTypeParameters(
-        child.typeArguments
-      );
-    }
-    return classImplementsNode;
-  }
-
-  /**
-   * Converts a child into a interface heritage node.
+   * Converts a child into a specified heritage node.
+   * @param {AST_NODE_TYPES} nodeType Type of node to be used
    * @param {ts.ExpressionWithTypeArguments} child The TypeScript AST node to convert.
-   * @returns {ESTreeNode} The type annotation node.
+   * @returns {ESTreeNode} The heritage node.
    */
-  function convertInterfaceHeritageClause(
+  function convertHeritageClause(
+    nodeType: AST_NODE_TYPES,
     child: ts.ExpressionWithTypeArguments
   ): ESTreeNode {
-    const id = convertChild(child.expression) as ESTreeNode;
+    const id = convertChild(child.expression)!;
     const classImplementsNode: ESTreeNode = {
-      type: AST_NODE_TYPES.TSInterfaceHeritage,
+      type: nodeType,
       loc: id.loc,
       range: id.range,
       id
     };
-
     if (child.typeArguments && child.typeArguments.length) {
       classImplementsNode.typeParameters = convertTypeArgumentsToTypeParameters(
         child.typeArguments
@@ -488,21 +471,11 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
     case SyntaxKind.SourceFile:
       Object.assign(result, {
         type: AST_NODE_TYPES.Program,
-        body: [],
+        body: convertBodyExpressions(node.statements),
         // externalModuleIndicator is internal field in TSC
         sourceType: (node as any).externalModuleIndicator ? 'module' : 'script'
       });
 
-      // filter out unknown nodes for now
-      node.statements.forEach((statement: any) => {
-        const convertedStatement = convertChild(statement);
-        if (convertedStatement) {
-          result.body.push(convertedStatement);
-        }
-      });
-
-      convertBodyExpressionsToDirectives();
-
       result.range[1] = node.endOfFileToken.end;
       result.loc = nodeUtils.getLocFor(
         node.getStart(ast),
@@ -514,10 +487,8 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
     case SyntaxKind.Block:
       Object.assign(result, {
         type: AST_NODE_TYPES.BlockStatement,
-        body: node.statements.map(convertChild)
+        body: convertBodyExpressions(node.statements)
       });
-
-      convertBodyExpressionsToDirectives();
       break;
 
     case SyntaxKind.Identifier:
@@ -1605,8 +1576,9 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
       });
 
       if (implementsClause) {
-        (result as any).implements = implementsClause.types.map(
-          convertClassImplements
+        (result as any).implements = implementsClause.types.map(el =>
+          // ClassImplements node to match what Flow does.
+          convertHeritageClause(AST_NODE_TYPES.ClassImplements, el)
         );
       }
 
@@ -1636,10 +1608,8 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
     case SyntaxKind.ModuleBlock:
       Object.assign(result, {
         type: AST_NODE_TYPES.TSModuleBlock,
-        body: node.statements.map(convertChild)
+        body: convertBodyExpressions(node.statements)
       });
-
-      convertBodyExpressionsToDirectives();
       break;
 
     case SyntaxKind.ImportDeclaration:
@@ -2236,7 +2206,7 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
     case SyntaxKind.TypeParameter: {
       Object.assign(result, {
         type: AST_NODE_TYPES.TSTypeParameter,
-        name: node.name.text,
+        name: convertChildType(node.name),
         constraint: node.constraint
           ? convertChildType(node.constraint)
           : undefined,
@@ -2525,8 +2495,8 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
 
       const interfaceBody = {
         type: AST_NODE_TYPES.TSInterfaceBody,
-        body: node.members.map((member: any) => convertChild(member)),
-        range: [interfaceOpenBrace.getStart(ast), result.range[1]],
+        body: node.members.map(member => convertChild(member)),
+        range: [interfaceOpenBrace.getStart(ast), node.end],
         loc: nodeUtils.getLocFor(
           interfaceOpenBrace.getStart(ast),
           node.end,
@@ -2539,8 +2509,8 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
         body: interfaceBody,
         id: convertChild(node.name),
         heritage: hasImplementsClause
-          ? interfaceHeritageClauses[0].types.map(
-              convertInterfaceHeritageClause
+          ? interfaceHeritageClauses[0].types.map(el =>
+              convertHeritageClause(AST_NODE_TYPES.TSInterfaceHeritage, el)
             )
           : []
       });

src/temp-types-based-on-js-source.ts

@@ -30,6 +30,8 @@ export interface ESTreeNode {
   typeAnnotation?: ESTreeNode | null;
   typeParameters?: ESTreeNode | null;
   id?: ESTreeNode | null;
+  raw?: string;
+  value?: string;
   expression?: ESTreeNode | null;
   decorators?: (ESTreeNode | null)[];
   const?: boolean;

tests/ast-alignment/utils.ts

@@ -1,4 +1,5 @@
 import isPlainObject from 'lodash.isplainobject';
+import { AST_NODE_TYPES } from '../../src/ast-node-types';
 
 /**
  * By default, pretty-format (within Jest matchers) retains the names/types of nodes from the babylon AST,
@@ -194,6 +195,29 @@ export function preprocessBabylonAST(ast: any): any {
           node.params = node.parameters;
           delete node.parameters;
         }
+      },
+      /**
+       * We want this node to be different
+       * @see https://github.com/JamesHenry/typescript-estree/issues/109
+       */
+      TSTypeParameter(node: any) {
+        if (node.name) {
+          node.name = {
+            loc: {
+              start: {
+                column: node.loc.start.column,
+                line: node.loc.start.line
+              },
+              end: {
+                column: node.loc.start.column + node.name.length,
+                line: node.loc.start.line
+              }
+            },
+            name: node.name,
+            range: [node.range[0], node.range[0] + node.name.length],
+            type: AST_NODE_TYPES.Identifier
+          };
+        }
       }
     }
   );