feat: Specify scriptkind for files to correctly parse usages

Author: shobhitg

src/TypescriptParser.ts

@@ -12,13 +12,15 @@ import {
     InterfaceDeclaration,
     ModuleDeclaration,
     Node,
+    ScriptKind,
     ScriptTarget,
     SourceFile,
     SyntaxKind,
     TypeAliasDeclaration,
     VariableStatement,
 } from 'typescript';
 
+import { parse } from 'path';
 import { parseClass } from './node-parser/class-parser';
 import { parseEnum } from './node-parser/enum-parser';
 import { parseExport } from './node-parser/export-parser';
@@ -37,31 +39,39 @@ import { Resource } from './resources/Resource';
  * This class is the parser of the whole extension. It uses the typescript compiler to parse a file or given
  * source code into the token stream and therefore into the AST of the source. Afterwards an array of
  * resources is generated and returned.
- * 
+ *
  * @export
  * @class TypescriptParser
  */
 export class TypescriptParser {
     /**
      * Parses the given source into an anonymous File resource.
      * Mainly used to parse source code of a document.
-     * 
+     *
      * @param {string} source
+     * @param {ScriptKind} [scriptKind=ScriptKind.TS]
      * @returns {Promise<File>}
-     * 
+     *
      * @memberof TsResourceParser
      */
-    public async parseSource(source: string): Promise<File> {
-        return await this.parseTypescript(createSourceFile('inline.tsx', source, ScriptTarget.ES2015, true), '/');
+    public async parseSource(source: string, scriptKind: ScriptKind = ScriptKind.TS): Promise<File> {
+        return await this.parseTypescript(
+          createSourceFile(
+              'inline.tsx',
+              source,
+              ScriptTarget.ES2015,
+              true,
+              scriptKind),
+          '/');
     }
 
     /**
      * Parses a single file into a parsed file.
-     * 
+     *
      * @param {string} filePath
      * @param {string} rootPath
      * @returns {Promise<File>}
-     * 
+     *
      * @memberof TsResourceParser
      */
     public async parseFile(filePath: string, rootPath: string): Promise<File> {
@@ -71,28 +81,52 @@ export class TypescriptParser {
 
     /**
      * Parses multiple files into parsed files.
-     * 
+     *
      * @param {string[]} filePathes
      * @param {string} rootPath
      * @returns {Promise<File[]>}
-     * 
+     *
      * @memberof TsResourceParser
      */
-    public async parseFiles(filePathes: string[], rootPath: string): Promise<File[]> {
+    public async parseFiles(
+        filePathes: string[],
+        rootPath: string): Promise<File[]> {
         return filePathes
-            .map(o => createSourceFile(o, readFileSync(o).toString(), ScriptTarget.ES2015, true))
+            .map((o) => {
+                let scriptKind: ScriptKind = ScriptKind.Unknown;
+                const parsed = parse(o);
+                switch (parsed.ext.toLowerCase()) {
+                    case 'js':
+                        scriptKind = ScriptKind.JS;
+                        break;
+                    case 'jsx':
+                        scriptKind = ScriptKind.JSX;
+                        break;
+                    case 'ts':
+                        scriptKind = ScriptKind.TS;
+                        break;
+                    case 'tsx':
+                        scriptKind = ScriptKind.TSX;
+                        break;
+                }
+                return createSourceFile(o,
+                                        readFileSync(o).toString(),
+                                        ScriptTarget.ES2015,
+                                        true,
+                                        scriptKind);
+            })
             .map(o => this.parseTypescript(o, rootPath));
     }
 
     /**
      * Parses the typescript source into the file instance. Calls .parse afterwards to
      * get the declarations and other information about the source.
-     * 
+     *
      * @private
      * @param {SourceFile} source
      * @param {string} rootPath
      * @returns {TsFile}
-     * 
+     *
      * @memberof TsResourceParser
      */
     private parseTypescript(source: SourceFile, rootPath: string): File {
@@ -108,11 +142,11 @@ export class TypescriptParser {
      * Recursive function that runs through the AST of a source and parses the nodes.
      * Creates the class / function / etc declarations and instanciates a new module / namespace
      * resource if needed.
-     * 
+     *
      * @private
      * @param {Resource} resource
      * @param {Node} node
-     * 
+     *
      * @memberof TsResourceParser
      */
     private parse(resource: Resource, node: Node): void {

test/TypescriptParser.spec.ts

@@ -1,4 +1,5 @@
 import { readFileSync } from 'fs';
+import { ScriptKind } from 'typescript';
 
 import { ClassDeclaration } from '../src/declarations/ClassDeclaration';
 import { DeclarationVisibility } from '../src/declarations/DeclarationVisibility';
@@ -617,7 +618,7 @@ describe('TypescriptParser', () => {
         });
 
         it('should parseSource correctly', async () => {
-            const parsedSource = await parser.parseSource(readFileSync(file).toString());
+            const parsedSource = await parser.parseSource(readFileSync(file).toString(), ScriptKind.TSX);
 
             expect(parsedSource.usages).toMatchSnapshot();
         });
@@ -679,7 +680,7 @@ describe('TypescriptParser', () => {
             it('should parse the correct usages with "parseSource"', async () => {
                 const file = getWorkspaceFile(`typescript-parser/specific-cases/${testFile.filename}`);
                 const fileSource = readFileSync(file).toString();
-                const parsed = await parser.parseSource(fileSource);
+                const parsed = await parser.parseSource(fileSource, ScriptKind.TSX);
 
                 for (const usage of testFile.requiredUsages) {
                     expect(parsed.usages).toContain(usage);
@@ -714,7 +715,7 @@ describe('TypescriptParser', () => {
 
         it('should parse a simple javascript file correctly with "parseSource"', async () => {
             const content = readFileSync(file).toString();
-            const parsed = await parser.parseSource(content);
+            const parsed = await parser.parseSource(content, ScriptKind.JS);
 
             expect(parsed).toMatchSnapshot();
         });
@@ -743,7 +744,7 @@ describe('TypescriptParser', () => {
 
         it('should parse a simple javascript react file correctly with "parseSource"', async () => {
             const content = readFileSync(file).toString();
-            const parsed = await parser.parseSource(content);
+            const parsed = await parser.parseSource(content, ScriptKind.JSX);
 
             expect(parsed).toMatchSnapshot();
         });
@@ -757,7 +758,7 @@ describe('TypescriptParser', () => {
                 public test() {
                     let a = <T>() => { let b = null; };
                 }
-            }`);
+            }`, ScriptKind.TS);
             expect(parsed).toMatchSnapshot();
         });
 

test/__snapshots__/TypescriptParser.spec.ts.snap

@@ -1492,21 +1492,29 @@ File {
       "isExported": true,
       "methods": Array [
         MethodDeclaration {
-          "end": 144,
+          "end": 130,
           "isAbstract": false,
           "name": "test",
           "parameters": Array [],
           "start": 41,
           "type": undefined,
           "variables": Array [
             VariableDeclaration {
-              "end": 144,
+              "end": 112,
               "isConst": false,
               "isExported": false,
               "name": "a",
               "start": 77,
               "type": undefined,
             },
+            VariableDeclaration {
+              "end": 109,
+              "isConst": false,
+              "isExported": false,
+              "name": "b",
+              "start": 96,
+              "type": undefined,
+            },
           ],
           "visibility": 2,
         },
@@ -1526,9 +1534,7 @@ File {
   "usages": Array [
     "a",
     "T",
-    "let",
-    undefined,
-    "",
+    "b",
   ],
 }
 `;