Fix implicit config on old ts versions (#2064)

* Fix bug where ts-node would try to use a @tsconfig/bases that is incompatible with the user's very old version of TS

* add ts 4.7 to test matrix

* adjust implicit tsconfig tests to understand and expect fallback to empty defaults when *none* of the tsconfig/bases are compatible

* fix useDefineForClassFields to be immune to implicit config
conditionally skip cases that use target incompatible with ts version
Add useDefineForClassFields test cases for es5 emit

* use more robust compatibility check: ask ts API to parse the options, check for errors

* Fix failing test where I guess swc decided to start quoting import strings differently?

* make more tests immune to blank implicit config

* jk about that quoting change :/

* fix test bug

Author: cspotcode

.github/workflows/continuous-integration.yml

@@ -63,7 +63,7 @@ jobs:
       matrix:
         os: [ubuntu, windows]
         # Don't forget to add all new flavors to this list!
-        flavor: [1, 2, 3, 4, 5, 6]
+        flavor: [1, 2, 3, 4, 5, 6, 7]
         include:
           # Node 16
           - flavor: 1
@@ -76,25 +76,30 @@ jobs:
             nodeFlag: 16
             typescript: 4.4
             typescriptFlag: 4_4
-          # Node 18
           - flavor: 3
+            node: 16
+            nodeFlag: 16
+            typescript: 4.7
+            typescriptFlag: 4_7
+          # Node 18
+          - flavor: 4
             node: 18
             nodeFlag: 18
             typescript: latest
             typescriptFlag: latest
-          - flavor: 4
+          - flavor: 5
             node: 18
             nodeFlag: 18
             typescript: next
             typescriptFlag: next
           # Node 20
-          - flavor: 5
+          - flavor: 6
             node: 20
             nodeFlag: 20
             typescript: latest
             typescriptFlag: latest
           # Node nightly
-          - flavor: 6
+          - flavor: 7
             node: 21-nightly
             nodeFlag: 21_nightly
             typescript: latest

src/test/transpilers.spec.ts

@@ -11,6 +11,7 @@ import {
   TEST_DIR,
   tsSupportsImportAssertions,
   tsSupportsReact17JsxFactories,
+  tsSupportsEs2022,
 } from './helpers';
 import { createSwcOptions } from '../transpilers/swc';
 import * as expect from 'expect';
@@ -101,15 +102,15 @@ test.suite('swc', (test) => {
 
     test(
       compileMacro,
-      { module: 'esnext', jsx: 'react' },
+      { module: 'esnext', target: 'es2020', jsx: 'react' },
       input,
       `const div = /*#__PURE__*/ React.createElement("div", null);`
     );
     test.suite('react 17 jsx factories', (test) => {
       test.if(tsSupportsReact17JsxFactories);
       test(
         compileMacro,
-        { module: 'esnext', jsx: 'react-jsx' },
+        { module: 'esnext', target: 'es2020', jsx: 'react-jsx' },
         input,
         outdent`
           import { jsx as _jsx } from "react/jsx-runtime";
@@ -118,7 +119,7 @@ test.suite('swc', (test) => {
       );
       test(
         compileMacro,
-        { module: 'esnext', jsx: 'react-jsxdev' },
+        { module: 'esnext', target: 'es2020', jsx: 'react-jsxdev' },
         input,
         outdent`
           import { jsxDEV as _jsxDEV } from "react/jsx-dev-runtime";
@@ -169,6 +170,18 @@ test.suite('swc', (test) => {
           }
       };
     `;
+    const outputCtorAssignmentInEs5Class = outdent`
+      function _class_call_check(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+          }
+      }
+      var Foo = function Foo() {
+          "use strict";
+          _class_call_check(this, Foo);
+          this.bar = 1;
+      };
+    `;
     const outputDefine = outdent`
       function _define_property(obj, key, value) {
           if (key in obj) {
@@ -189,19 +202,44 @@ test.suite('swc', (test) => {
           }
       };
     `;
+    const outputDefineInEs5Class = outdent`
+      function _class_call_check(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+          }
+      }
+      function _define_property(obj, key, value) {
+          if (key in obj) {
+              Object.defineProperty(obj, key, {
+                  value: value,
+                  enumerable: true,
+                  configurable: true,
+                  writable: true
+              });
+          } else {
+              obj[key] = value;
+          }
+          return obj;
+      }
+      var Foo = function Foo() {
+          "use strict";
+          _class_call_check(this, Foo);
+          _define_property(this, "bar", 1);
+      };
+    `;
     test(
-      'useDefineForClassFields unset, should default to true and emit native property assignment b/c `next` target',
+      'useDefineForClassFields unset, `next` target, should default to true and emit native property assignment',
       compileMacro,
       { module: 'esnext', target: 'ESNext' },
       input,
       outputNative
     );
-    test(
-      'useDefineForClassFields unset, should default to true and emit native property assignment b/c new target',
-      compileMacro,
-      { module: 'esnext', target: 'ES2022' },
-      input,
-      outputNative
+    test.suite(
+      'useDefineForClassFields unset, new target, should default to true and emit native property assignment',
+      (test) => {
+        test.if(tsSupportsEs2022);
+        test(compileMacro, { module: 'esnext', target: 'ES2022' }, input, outputNative);
+      }
     );
     test(
       'useDefineForClassFields unset, should default to false b/c old target',
@@ -210,48 +248,78 @@ test.suite('swc', (test) => {
       input,
       outputCtorAssignment
     );
+    test.suite('useDefineForClassFields=true, new target, should emit native property assignment', (test) => {
+      test.if(tsSupportsEs2022);
+      test(
+        compileMacro,
+        {
+          module: 'esnext',
+          target: 'ES2022',
+          useDefineForClassFields: true,
+        },
+        input,
+        outputNative
+      );
+    });
     test(
-      'useDefineForClassFields=true, should emit native property assignment b/c new target',
+      'useDefineForClassFields=true, old target, should emit define',
       compileMacro,
       {
         module: 'esnext',
+        target: 'ES2021',
         useDefineForClassFields: true,
-        target: 'ES2022',
       },
       input,
-      outputNative
+      outputDefine
+    );
+    test.suite(
+      'useDefineForClassFields=false, new target, should still emit legacy property assignment in ctor',
+      (test) => {
+        test.if(tsSupportsEs2022);
+        test(
+          compileMacro,
+          {
+            module: 'esnext',
+            target: 'ES2022',
+            useDefineForClassFields: false,
+          },
+          input,
+          outputCtorAssignment
+        );
+      }
     );
     test(
-      'useDefineForClassFields=true, should emit define b/c old target',
+      'useDefineForClassFields=false, old target, should emit legacy property assignment in ctor',
       compileMacro,
       {
         module: 'esnext',
-        useDefineForClassFields: true,
         target: 'ES2021',
+        useDefineForClassFields: false,
       },
       input,
-      outputDefine
+      outputCtorAssignment
     );
     test(
-      'useDefineForClassFields=false, new target, should still emit legacy property assignment in ctor',
+      'useDefineForClassFields=false, ancient target, should emit legacy property assignment in legacy function-based class',
       compileMacro,
       {
         module: 'esnext',
+        target: 'es5',
         useDefineForClassFields: false,
-        target: 'ES2022',
       },
       input,
-      outputCtorAssignment
+      outputCtorAssignmentInEs5Class
     );
     test(
-      'useDefineForClassFields=false, old target, should emit legacy property assignment in ctor',
+      'useDefineForClassFields=true, ancient target, should emit define in legacy function-based class',
       compileMacro,
       {
         module: 'esnext',
-        useDefineForClassFields: false,
+        target: 'es5',
+        useDefineForClassFields: true,
       },
       input,
-      outputCtorAssignment
+      outputDefineInEs5Class
     );
   });
 

src/test/tsconfig-bases.spec.ts

@@ -3,7 +3,12 @@ import { createExec } from './helpers/exec';
 import { ctxTmpDirOutsideCheckout } from './helpers/ctx-tmp-dir';
 import { ctxTsNode } from './helpers/ctx-ts-node';
 import { BIN_PATH, TEST_DIR } from './helpers/paths';
-import { tsSupportsEs2021, tsSupportsEs2022, tsSupportsLibEs2023 } from './helpers/version-checks';
+import {
+  tsSupportsEs2021,
+  tsSupportsEs2022,
+  tsSupportsLibEs2023,
+  tsSupportsStableNodeNextNode16,
+} from './helpers/version-checks';
 import { context, expect } from './testlib';
 import semver = require('semver');
 import { testsDirRequire } from './helpers';
@@ -17,14 +22,21 @@ const test = context(ctxTsNode);
 test.suite('should use implicit @tsconfig/bases config when one is not loaded from disk', ({ contextEach }) => {
   const test = contextEach(ctxTmpDirOutsideCheckout);
 
-  let lib = 'es2020';
-  let target = 'es2020';
-  if (semver.gte(process.versions.node, '16.0.0') && tsSupportsEs2021) {
-    lib = target = 'es2021';
-  }
-  if (semver.gte(process.versions.node, '18.0.0') && tsSupportsEs2022 && tsSupportsLibEs2023) {
-    target = 'es2022';
-    lib = 'es2023';
+  // Expectations change depending on node and TS version, since ts-node picks an implicit config that is compatible
+  // with both.
+  let lib: Array<string> | undefined = undefined;
+  let target: string = 'es5';
+  if (tsSupportsStableNodeNextNode16) {
+    lib = ['es2020'];
+    target = 'es2020';
+    if (semver.gte(process.versions.node, '16.0.0') && tsSupportsEs2021) {
+      lib = ['es2021'];
+      target = 'es2021';
+    }
+    if (semver.gte(process.versions.node, '18.0.0') && tsSupportsEs2022 && tsSupportsLibEs2023) {
+      lib = ['es2023'];
+      target = 'es2022';
+    }
   }
 
   test('implicitly uses @tsconfig/node14, @tsconfig/node16, @tsconfig/node18, or @tsconfig/node20 compilerOptions when both TS and node versions support it', async (t) => {
@@ -36,16 +48,9 @@ test.suite('should use implicit @tsconfig/bases config when one is not loaded fr
     t.like(JSON.parse(r1.stdout), {
       compilerOptions: {
         target,
-        lib: [lib],
+        lib,
       },
     });
-
-    const r2 = await exec(`${BIN_PATH} -pe 10n`, {
-      cwd: t.context.tmpDir,
-    });
-
-    expect(r2.err).toBe(null);
-    expect(r2.stdout).toBe('10n\n');
   });
 
   test('implicitly loads @types/node even when not installed within local directory', async (t) => {
@@ -73,8 +78,8 @@ test.suite('should use implicit @tsconfig/bases config when one is not loaded fr
 });
 
 test.suite('should bundle @tsconfig/bases to be used in your own tsconfigs', (test) => {
-  // Older TS versions will complain about newer `target` and `lib` options
-  test.if(tsSupportsEs2022 && tsSupportsLibEs2023);
+  // Older TS versions will complain about newer `target`, `lib`, `module`, `moduleResolution` options
+  test.if(tsSupportsEs2022 && tsSupportsLibEs2023 && tsSupportsStableNodeNextNode16);
 
   const macro = test.macro((nodeVersion: string) => async (t) => {
     const config = testsDirRequire(`@tsconfig/${nodeVersion}/tsconfig.json`);

src/tsconfigs.ts

@@ -20,19 +20,50 @@ export function getDefaultTsconfigJsonForNodeVersion(ts: TSCommon): any {
     const config = require('@tsconfig/node16/tsconfig.json');
     if (configCompatible(config)) return config;
   }
-  return require('@tsconfig/node14/tsconfig.json');
+  {
+    const config = require('@tsconfig/node14/tsconfig.json');
+    if (configCompatible(config)) return config;
+  }
+  // Old TypeScript compilers may be incompatible with *all* @tsconfig/node* configs,
+  // so fallback to nothing
+  return {};
 
   // Verify that tsconfig target and lib options are compatible with TypeScript compiler
   function configCompatible(config: {
     compilerOptions: {
       lib: string[];
       target: string;
+      module: string;
+      moduleResolution: string;
     };
   }) {
-    return (
-      typeof (ts.ScriptTarget as any)[config.compilerOptions.target.toUpperCase()] === 'number' &&
-      tsInternal.libs &&
-      config.compilerOptions.lib.every((lib) => tsInternal.libs!.includes(lib))
+    const results = ts.parseJsonConfigFileContent(
+      {
+        compilerOptions: config.compilerOptions,
+        files: ['foo.ts'],
+      },
+      parseConfigHost,
+      ''
     );
+    return results.errors.length === 0;
   }
 }
+
+const parseConfigHost = {
+  useCaseSensitiveFileNames: false,
+  readDirectory(
+    rootDir: string,
+    extensions: readonly string[],
+    excludes: readonly string[] | undefined,
+    includes: readonly string[],
+    depth?: number
+  ) {
+    return [];
+  },
+  fileExists(path: string) {
+    return false;
+  },
+  readFile(path: string) {
+    return '';
+  },
+};