Don't elide imports when transforming JS files

src/compiler/checker.ts

@@ -1837,8 +1837,9 @@ namespace ts {
             nameArg: __String | Identifier | undefined,
             isUse: boolean,
             excludeGlobals = false,
-            getSpellingSuggstions = true): Symbol | undefined {
-            return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggstions, getSymbol);
+            getSpellingSuggestions = true,
+            reportErrors = true): Symbol | undefined {
+            return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, getSymbol, reportErrors);
         }
 
         function resolveNameHelper(
@@ -1850,7 +1851,8 @@ namespace ts {
             isUse: boolean,
             excludeGlobals: boolean,
             getSpellingSuggestions: boolean,
-            lookup: typeof getSymbol): Symbol | undefined {
+            lookup: typeof getSymbol,
+            reportErrors = true): Symbol | undefined {
             const originalLocation = location; // needed for did-you-mean error reporting, which gathers candidates starting from the original location
             let result: Symbol | undefined;
             let lastLocation: Node | undefined;
@@ -2011,7 +2013,9 @@ namespace ts {
                                 // TypeScript 1.0 spec (April 2014): 3.4.1
                                 // The scope of a type parameter extends over the entire declaration with which the type
                                 // parameter list is associated, with the exception of static member declarations in classes.
-                                error(errorLocation, Diagnostics.Static_members_cannot_reference_class_type_parameters);
+                                if (reportErrors) {
+                                    error(errorLocation, Diagnostics.Static_members_cannot_reference_class_type_parameters);
+                                }
                                 return undefined;
                             }
                             break loop;
@@ -2029,7 +2033,7 @@ namespace ts {
                         if (lastLocation === (location as ExpressionWithTypeArguments).expression && (location.parent as HeritageClause).token === SyntaxKind.ExtendsKeyword) {
                             const container = location.parent.parent;
                             if (isClassLike(container) && (result = lookup(getSymbolOfNode(container).members!, name, meaning & SymbolFlags.Type))) {
-                                if (nameNotFoundMessage) {
+                                if (reportErrors && nameNotFoundMessage) {
                                     error(errorLocation, Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
                                 }
                                 return undefined;
@@ -2049,7 +2053,9 @@ namespace ts {
                         if (isClassLike(grandparent) || grandparent.kind === SyntaxKind.InterfaceDeclaration) {
                             // A reference to this grandparent's type parameters would be an error
                             if (result = lookup(getSymbolOfNode(grandparent as ClassLikeDeclaration | InterfaceDeclaration).members!, name, meaning & SymbolFlags.Type)) {
-                                error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+                                if (reportErrors) {
+                                    error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+                                }
                                 return undefined;
                             }
                         }
@@ -2206,7 +2212,7 @@ namespace ts {
             }
 
             if (!result) {
-                if (nameNotFoundMessage) {
+                if (reportErrors && nameNotFoundMessage) {
                     addLazyDiagnostic(() => {
                         if (!errorLocation ||
                             !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg!) && // TODO: GH#18217
@@ -2259,12 +2265,12 @@ namespace ts {
                 }
                 return undefined;
             }
-            else if (checkAndReportErrorForInvalidInitializer()) {
+            else if (reportErrors && checkAndReportErrorForInvalidInitializer()) {
                 return undefined;
             }
 
             // Perform extra checks only if error reporting was requested
-            if (nameNotFoundMessage) {
+            if (reportErrors && nameNotFoundMessage) {
                 addLazyDiagnostic(() => {
                     // Only check for block-scoped variable if we have an error location and are looking for the
                     // name with variable meaning
@@ -43070,7 +43076,8 @@ namespace ts {
             }
             const node = getParseTreeNode(nodeIn, isIdentifier);
             if (node) {
-                const symbol = getReferencedValueSymbol(node);
+                const symbol = getReferencedSymbol(node, /*startInDeclarationContainer*/ undefined);
+
                 // We should only get the declaration of an alias if there isn't a local value
                 // declaration for the symbol
                 if (isNonLocalAlias(symbol, /*excludes*/ SymbolFlags.Value) && !getTypeOnlyAliasDeclaration(symbol)) {
@@ -43474,6 +43481,41 @@ namespace ts {
             return resolveName(location, reference.escapedText, SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true);
         }
 
+        /**
+         * Get either a value-meaning symbol or an alias symbol.
+         * Unlike `getReferencedValueSymbol`, if the cached resolved symbol is the unknown symbol,
+         * we call `resolveName` to find a symbol.
+         * This is because when caching the resolved symbol, we only consider value symbols, but here
+         * we want to also get an alias symbol if one exists.
+         */
+        function getReferencedSymbol(reference: Identifier, startInDeclarationContainer?: boolean): Symbol | undefined {
+            const resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
+            if (resolvedSymbol && resolvedSymbol !== unknownSymbol) {
+                return resolvedSymbol;
+            }
+
+            let location: Node = reference;
+            if (startInDeclarationContainer) {
+                // When resolving the name of a declaration as a value, we need to start resolution
+                // at a point outside of the declaration.
+                const parent = reference.parent;
+                if (isDeclaration(parent) && reference === parent.name) {
+                    location = getDeclarationContainer(parent);
+                }
+            }
+
+            return resolveName(
+                location,
+                reference.escapedText,
+                SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias,
+                /*nodeNotFoundMessage*/ undefined,
+                /*nameArg*/ undefined,
+                /*isUse*/ true,
+                /*excludeGlobals*/ undefined,
+                /*getSpellingSuggestions*/ undefined,
+                /*reportErrors*/ false);
+        }
+
         function getReferencedValueDeclaration(referenceIn: Identifier): Declaration | undefined {
             if (!isGeneratedIdentifier(referenceIn)) {
                 const reference = getParseTreeNode(referenceIn, isIdentifier);

src/compiler/transformers/ts.ts

@@ -2455,9 +2455,11 @@ namespace ts {
         }
 
         function shouldEmitAliasDeclaration(node: Node): boolean {
-            return compilerOptions.preserveValueImports
-                ? resolver.isValueAliasDeclaration(node)
-                : resolver.isReferencedAliasDeclaration(node);
+            return isInJSFile(node)
+                ? true
+                : compilerOptions.preserveValueImports
+                    ? resolver.isValueAliasDeclaration(node)
+                    : resolver.isReferencedAliasDeclaration(node);
         }
     }
 }

tests/baselines/reference/allowImportClausesToMergeWithTypes.js

@@ -45,7 +45,7 @@ b_1["default"];
 "use strict";
 exports.__esModule = true;
 var x = { x: "" };
-zzz;
+a_1["default"];
 var b_1 = require("./b");
 b_1["default"];
 var y = x;

tests/baselines/reference/elidedJSImport.js

@@ -0,0 +1,26 @@
+//// [tests/cases/compiler/elidedJSImport.ts] ////
+
+//// [caller.js]
+import * as fs from 'fs';
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+console.log(fs);
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'
+
+
+//// [index.d.ts]
+declare module "@truffle/contract" {
+    // import { ContractObject } from "@truffle/contract-schema";
+    interface ContractObject {
+        foo: number;
+    }
+    namespace TruffleContract {
+        export type Contract = ContractObject;
+    }
+    export default TruffleContract;
+}
+
+//// [caller.js]
+import * as fs from 'fs';
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+console.log(fs);
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'

tests/baselines/reference/elidedJSImport.symbols

@@ -0,0 +1,40 @@
+=== tests/cases/compiler/caller.js ===
+import * as fs from 'fs';
+>fs : Symbol(fs, Decl(caller.js, 0, 6))
+
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+>TruffleContract : Symbol(TruffleContract, Decl(caller.js, 1, 6))
+
+console.log(fs);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>fs : Symbol(fs, Decl(caller.js, 0, 6))
+
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+
+
+=== tests/cases/compiler/node_modules/@truffle/contract/index.d.ts ===
+declare module "@truffle/contract" {
+>"@truffle/contract" : Symbol("@truffle/contract", Decl(index.d.ts, 0, 0))
+
+    // import { ContractObject } from "@truffle/contract-schema";
+    interface ContractObject {
+>ContractObject : Symbol(ContractObject, Decl(index.d.ts, 0, 36))
+
+        foo: number;
+>foo : Symbol(ContractObject.foo, Decl(index.d.ts, 2, 30))
+    }
+    namespace TruffleContract {
+>TruffleContract : Symbol(TruffleContract, Decl(index.d.ts, 4, 5))
+
+        export type Contract = ContractObject;
+>Contract : Symbol(Contract, Decl(index.d.ts, 5, 31))
+>ContractObject : Symbol(ContractObject, Decl(index.d.ts, 0, 36))
+    }
+    export default TruffleContract;
+>TruffleContract : Symbol(TruffleContract, Decl(index.d.ts, 4, 5))
+}

tests/baselines/reference/elidedJSImport.types

@@ -0,0 +1,41 @@
+=== tests/cases/compiler/caller.js ===
+import * as fs from 'fs';
+>fs : error
+
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+>TruffleContract : any
+
+console.log(fs);
+>console.log(fs) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>fs : error
+
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'
+>console.log('TruffleContract is ', typeof TruffleContract, TruffleContract) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>'TruffleContract is ' : "TruffleContract is "
+>typeof TruffleContract : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>TruffleContract : error
+>TruffleContract : error
+
+
+=== tests/cases/compiler/node_modules/@truffle/contract/index.d.ts ===
+declare module "@truffle/contract" {
+>"@truffle/contract" : typeof import("@truffle/contract")
+
+    // import { ContractObject } from "@truffle/contract-schema";
+    interface ContractObject {
+        foo: number;
+>foo : number
+    }
+    namespace TruffleContract {
+        export type Contract = ContractObject;
+>Contract : ContractObject
+    }
+    export default TruffleContract;
+>TruffleContract : any
+}

tests/baselines/reference/elidedJSImport1.errors.txt

@@ -0,0 +1,31 @@
+tests/cases/compiler/caller.js(1,21): error TS2307: Cannot find module 'fs' or its corresponding type declarations.
+tests/cases/compiler/caller.js(2,8): error TS18042: 'TruffleContract' is a type and cannot be imported in JavaScript files. Use 'import("@truffle/contract").TruffleContract' in a JSDoc type annotation.
+tests/cases/compiler/caller.js(4,43): error TS2708: Cannot use namespace 'TruffleContract' as a value.
+tests/cases/compiler/caller.js(4,60): error TS2708: Cannot use namespace 'TruffleContract' as a value.
+
+
+==== tests/cases/compiler/caller.js (4 errors) ====
+    import * as fs from 'fs';
+                        ~~~~
+!!! error TS2307: Cannot find module 'fs' or its corresponding type declarations.
+    import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+           ~~~~~~~~~~~~~~~
+!!! error TS18042: 'TruffleContract' is a type and cannot be imported in JavaScript files. Use 'import("@truffle/contract").TruffleContract' in a JSDoc type annotation.
+    console.log(fs);
+    console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'
+                                              ~~~~~~~~~~~~~~~
+!!! error TS2708: Cannot use namespace 'TruffleContract' as a value.
+                                                               ~~~~~~~~~~~~~~~
+!!! error TS2708: Cannot use namespace 'TruffleContract' as a value.
+
+
+==== tests/cases/compiler/node_modules/@truffle/contract/index.d.ts (0 errors) ====
+    declare module "@truffle/contract" {
+        interface ContractObject {
+            foo: number;
+        }
+        namespace TruffleContract {
+            export type Contract = ContractObject;
+        }
+        export default TruffleContract;
+    }

tests/baselines/reference/elidedJSImport1.js

@@ -0,0 +1,25 @@
+//// [tests/cases/compiler/elidedJSImport1.ts] ////
+
+//// [caller.js]
+import * as fs from 'fs';
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+console.log(fs);
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'
+
+
+//// [index.d.ts]
+declare module "@truffle/contract" {
+    interface ContractObject {
+        foo: number;
+    }
+    namespace TruffleContract {
+        export type Contract = ContractObject;
+    }
+    export default TruffleContract;
+}
+
+//// [caller.js]
+import * as fs from 'fs';
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+console.log(fs);
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'

tests/baselines/reference/elidedJSImport1.symbols

@@ -0,0 +1,39 @@
+=== tests/cases/compiler/caller.js ===
+import * as fs from 'fs';
+>fs : Symbol(fs, Decl(caller.js, 0, 6))
+
+import TruffleContract from '@truffle/contract'; // Runtime err: this import is elided in transform
+>TruffleContract : Symbol(TruffleContract, Decl(caller.js, 1, 6))
+
+console.log(fs);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>fs : Symbol(fs, Decl(caller.js, 0, 6))
+
+console.log('TruffleContract is ', typeof TruffleContract, TruffleContract); // `TruffleContract` is considered 'unused'
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+
+
+=== tests/cases/compiler/node_modules/@truffle/contract/index.d.ts ===
+declare module "@truffle/contract" {
+>"@truffle/contract" : Symbol("@truffle/contract", Decl(index.d.ts, 0, 0))
+
+    interface ContractObject {
+>ContractObject : Symbol(ContractObject, Decl(index.d.ts, 0, 36))
+
+        foo: number;
+>foo : Symbol(ContractObject.foo, Decl(index.d.ts, 1, 30))
+    }
+    namespace TruffleContract {
+>TruffleContract : Symbol(TruffleContract, Decl(index.d.ts, 3, 5))
+
+        export type Contract = ContractObject;
+>Contract : Symbol(Contract, Decl(index.d.ts, 4, 31))
+>ContractObject : Symbol(ContractObject, Decl(index.d.ts, 0, 36))
+    }
+    export default TruffleContract;
+>TruffleContract : Symbol(TruffleContract, Decl(index.d.ts, 3, 5))
+}