typescript 5.4.0-dev.20231208 → 5.4.0-dev.20231209

package/lib/tsserver.js

@@ -333,6 +333,7 @@ __export(server_exports, {
   computeSignature: () => computeSignature,
   computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
   computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
+  computedOptions: () => computedOptions,
   concatenate: () => concatenate,
   concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
   consumesNodeCoreModules: () => consumesNodeCoreModules,
@@ -2334,7 +2335,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231208`;
+var version = `${versionMajorMinor}.0-dev.20231209`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -20522,37 +20523,230 @@ function getSetExternalModuleIndicator(options) {
       return callback;
   }
 }
-function getEmitScriptTarget(compilerOptions) {
-  return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
-}
-function getEmitModuleKind(compilerOptions) {
-  return typeof compilerOptions.module === "number" ? compilerOptions.module : getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
-}
-function emitModuleKindIsNonNodeESM(moduleKind) {
-  return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */;
+function createComputedCompilerOptions(options) {
+  return options;
 }
-function getEmitModuleResolutionKind(compilerOptions) {
-  let moduleResolution = compilerOptions.moduleResolution;
-  if (moduleResolution === void 0) {
-    switch (getEmitModuleKind(compilerOptions)) {
-      case 1 /* CommonJS */:
-        moduleResolution = 2 /* Node10 */;
-        break;
-      case 100 /* Node16 */:
-        moduleResolution = 3 /* Node16 */;
-        break;
-      case 199 /* NodeNext */:
-        moduleResolution = 99 /* NodeNext */;
-        break;
-      default:
-        moduleResolution = 1 /* Classic */;
-        break;
+var computedOptions = createComputedCompilerOptions({
+  target: {
+    dependencies: ["module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
+    }
+  },
+  module: {
+    dependencies: ["target"],
+    computeValue: (compilerOptions) => {
+      return typeof compilerOptions.module === "number" ? compilerOptions.module : computedOptions.target.computeValue(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
+    }
+  },
+  moduleResolution: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      let moduleResolution = compilerOptions.moduleResolution;
+      if (moduleResolution === void 0) {
+        switch (computedOptions.module.computeValue(compilerOptions)) {
+          case 1 /* CommonJS */:
+            moduleResolution = 2 /* Node10 */;
+            break;
+          case 100 /* Node16 */:
+            moduleResolution = 3 /* Node16 */;
+            break;
+          case 199 /* NodeNext */:
+            moduleResolution = 99 /* NodeNext */;
+            break;
+          default:
+            moduleResolution = 1 /* Classic */;
+            break;
+        }
+      }
+      return moduleResolution;
+    }
+  },
+  moduleDetection: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.moduleDetection || (computedOptions.module.computeValue(compilerOptions) === 100 /* Node16 */ || computedOptions.module.computeValue(compilerOptions) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
+    }
+  },
+  isolatedModules: {
+    dependencies: ["verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax);
+    }
+  },
+  esModuleInterop: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.esModuleInterop !== void 0) {
+        return compilerOptions.esModuleInterop;
+      }
+      switch (computedOptions.module.computeValue(compilerOptions)) {
+        case 100 /* Node16 */:
+        case 199 /* NodeNext */:
+          return true;
+      }
+      return false;
+    }
+  },
+  allowSyntheticDefaultImports: {
+    dependencies: ["module", "target", "moduleResolution"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
+        return compilerOptions.allowSyntheticDefaultImports;
+      }
+      return computedOptions.esModuleInterop.computeValue(compilerOptions) || computedOptions.module.computeValue(compilerOptions) === 4 /* System */ || computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  resolvePackageJsonExports: {
+    dependencies: ["moduleResolution"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolvePackageJsonImports: {
+    dependencies: ["moduleResolution", "resolvePackageJsonExports"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolveJsonModule: {
+    dependencies: ["moduleResolution", "module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.resolveJsonModule !== void 0) {
+        return compilerOptions.resolveJsonModule;
+      }
+      return computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  declaration: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declaration || compilerOptions.composite);
+    }
+  },
+  preserveConstEnums: {
+    dependencies: ["isolatedModules", "verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.preserveConstEnums || computedOptions.isolatedModules.computeValue(compilerOptions));
+    }
+  },
+  incremental: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.incremental || compilerOptions.composite);
+    }
+  },
+  declarationMap: {
+    dependencies: ["declaration", "composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declarationMap && computedOptions.declaration.computeValue(compilerOptions));
+    }
+  },
+  allowJs: {
+    dependencies: ["checkJs"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
+    }
+  },
+  useDefineForClassFields: {
+    dependencies: ["target", "module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.useDefineForClassFields === void 0 ? computedOptions.target.computeValue(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
+    }
+  },
+  noImplicitAny: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitAny");
+    }
+  },
+  noImplicitThis: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitThis");
+    }
+  },
+  strictNullChecks: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictNullChecks");
+    }
+  },
+  strictFunctionTypes: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictFunctionTypes");
+    }
+  },
+  strictBindCallApply: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictBindCallApply");
+    }
+  },
+  strictPropertyInitialization: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+    }
+  },
+  alwaysStrict: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "alwaysStrict");
+    }
+  },
+  useUnknownInCatchVariables: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
     }
   }
-  return moduleResolution;
-}
-function getEmitModuleDetectionKind(options) {
-  return options.moduleDetection || (getEmitModuleKind(options) === 100 /* Node16 */ || getEmitModuleKind(options) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
+});
+var getEmitScriptTarget = computedOptions.target.computeValue;
+var getEmitModuleKind = computedOptions.module.computeValue;
+var getEmitModuleResolutionKind = computedOptions.moduleResolution.computeValue;
+var getEmitModuleDetectionKind = computedOptions.moduleDetection.computeValue;
+var getIsolatedModules = computedOptions.isolatedModules.computeValue;
+var getESModuleInterop = computedOptions.esModuleInterop.computeValue;
+var getAllowSyntheticDefaultImports = computedOptions.allowSyntheticDefaultImports.computeValue;
+var getResolvePackageJsonExports = computedOptions.resolvePackageJsonExports.computeValue;
+var getResolvePackageJsonImports = computedOptions.resolvePackageJsonImports.computeValue;
+var getResolveJsonModule = computedOptions.resolveJsonModule.computeValue;
+var getEmitDeclarations = computedOptions.declaration.computeValue;
+var shouldPreserveConstEnums = computedOptions.preserveConstEnums.computeValue;
+var isIncrementalCompilation = computedOptions.incremental.computeValue;
+var getAreDeclarationMapsEnabled = computedOptions.declarationMap.computeValue;
+var getAllowJSCompilerOption = computedOptions.allowJs.computeValue;
+var getUseDefineForClassFields = computedOptions.useDefineForClassFields.computeValue;
+function emitModuleKindIsNonNodeESM(moduleKind) {
+  return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */;
 }
 function hasJsonModuleEmitEnabled(options) {
   switch (getEmitModuleKind(options)) {
@@ -20569,9 +20763,6 @@ function hasJsonModuleEmitEnabled(options) {
       return false;
   }
 }
-function getIsolatedModules(options) {
-  return !!(options.isolatedModules || options.verbatimModuleSyntax);
-}
 function importNameElisionDisabled(options) {
   return options.verbatimModuleSyntax || options.isolatedModules && options.preserveValueImports;
 }
@@ -20581,88 +20772,15 @@ function unreachableCodeIsError(options) {
 function unusedLabelIsError(options) {
   return options.allowUnusedLabels === false;
 }
-function getAreDeclarationMapsEnabled(options) {
-  return !!(getEmitDeclarations(options) && options.declarationMap);
-}
-function getESModuleInterop(compilerOptions) {
-  if (compilerOptions.esModuleInterop !== void 0) {
-    return compilerOptions.esModuleInterop;
-  }
-  switch (getEmitModuleKind(compilerOptions)) {
-    case 100 /* Node16 */:
-    case 199 /* NodeNext */:
-      return true;
-  }
-  return void 0;
-}
-function getAllowSyntheticDefaultImports(compilerOptions) {
-  if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
-    return compilerOptions.allowSyntheticDefaultImports;
-  }
-  return getESModuleInterop(compilerOptions) || getEmitModuleKind(compilerOptions) === 4 /* System */ || getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
 function moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution) {
   return moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */ || moduleResolution === 100 /* Bundler */;
 }
 function shouldResolveJsRequire(compilerOptions) {
   return !!compilerOptions.noDtsResolution || getEmitModuleResolutionKind(compilerOptions) !== 100 /* Bundler */;
 }
-function getResolvePackageJsonExports(compilerOptions) {
-  const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-    return false;
-  }
-  if (compilerOptions.resolvePackageJsonExports !== void 0) {
-    return compilerOptions.resolvePackageJsonExports;
-  }
-  switch (moduleResolution) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-    case 100 /* Bundler */:
-      return true;
-  }
-  return false;
-}
-function getResolvePackageJsonImports(compilerOptions) {
-  const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-    return false;
-  }
-  if (compilerOptions.resolvePackageJsonExports !== void 0) {
-    return compilerOptions.resolvePackageJsonExports;
-  }
-  switch (moduleResolution) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-    case 100 /* Bundler */:
-      return true;
-  }
-  return false;
-}
-function getResolveJsonModule(compilerOptions) {
-  if (compilerOptions.resolveJsonModule !== void 0) {
-    return compilerOptions.resolveJsonModule;
-  }
-  return getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
-function getEmitDeclarations(compilerOptions) {
-  return !!(compilerOptions.declaration || compilerOptions.composite);
-}
-function shouldPreserveConstEnums(compilerOptions) {
-  return !!(compilerOptions.preserveConstEnums || getIsolatedModules(compilerOptions));
-}
-function isIncrementalCompilation(options) {
-  return !!(options.incremental || options.composite);
-}
 function getStrictOptionValue(compilerOptions, flag) {
   return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
 }
-function getAllowJSCompilerOption(compilerOptions) {
-  return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
-}
-function getUseDefineForClassFields(compilerOptions) {
-  return compilerOptions.useDefineForClassFields === void 0 ? getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
-}
 function getEmitStandardClassFields(compilerOptions) {
   return compilerOptions.useDefineForClassFields !== false && getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */;
 }
@@ -40335,7 +40453,8 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     ),
     (f) => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName)
   );
-  const optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
+  const pathOptions = { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames };
+  const optionMap = serializeCompilerOptions(configParseResult.options, pathOptions);
   const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
   const config = {
     compilerOptions: {
@@ -40360,6 +40479,18 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     } : {},
     compileOnSave: !!configParseResult.compileOnSave ? true : void 0
   };
+  const providedKeys = new Set(optionMap.keys());
+  const impliedCompilerOptions = {};
+  for (const option in computedOptions) {
+    if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) {
+      const implied = computedOptions[option].computeValue(configParseResult.options);
+      const defaultValue = computedOptions[option].computeValue({});
+      if (implied !== defaultValue) {
+        impliedCompilerOptions[option] = computedOptions[option].computeValue(configParseResult.options);
+      }
+    }
+  }
+  assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
   return config;
 }
 function optionMapToObject(optionMap) {
@@ -63033,7 +63164,9 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
-      const checkTuples = isSimpleTupleType(root.node.checkType) && isSimpleTupleType(root.node.extendsType) && length(root.node.checkType.elements) === length(root.node.extendsType.elements);
+      const checkTypeNode = skipTypeParentheses(root.node.checkType);
+      const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
+      const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
       const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
@@ -159770,7 +159903,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   }
   const semanticStart = timestamp();
   let completionKind = 5 /* None */;
-  let isNonContextualObjectLiteral = false;
   let hasUnresolvedAutoImports = false;
   let symbols = [];
   let importSpecifierResolver;
@@ -160130,8 +160262,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   function shouldOfferImportCompletions() {
     if (importStatementCompletion)
       return true;
-    if (isNonContextualObjectLiteral)
-      return false;
     if (!preferences.includeCompletionsForModuleExports)
       return false;
     if (sourceFile.externalModuleIndicator || sourceFile.commonJsModuleIndicator)
@@ -160434,7 +160564,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         if (objectLikeContainer.flags & 67108864 /* InWithStatement */) {
           return 2 /* Fail */;
         }
-        isNonContextualObjectLiteral = true;
         return 0 /* Continue */;
       }
       const completionsType = typeChecker.getContextualType(objectLikeContainer, 4 /* Completions */);
@@ -160445,7 +160574,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       existingMembers = objectLikeContainer.properties;
       if (typeMembers.length === 0) {
         if (!hasNumberIndextype) {
-          isNonContextualObjectLiteral = true;
           return 0 /* Continue */;
         }
       }
@@ -167630,16 +167758,16 @@ function getRenameInfoForModule(node, sourceFile, moduleSymbol) {
   if (!moduleSourceFile)
     return void 0;
   const withoutIndex = endsWith(node.text, "/index") || endsWith(node.text, "/index.js") ? void 0 : tryRemoveSuffix(removeFileExtension(moduleSourceFile.fileName), "/index");
-  const name = withoutIndex === void 0 ? moduleSourceFile.fileName : withoutIndex;
+  const fileName = withoutIndex === void 0 ? moduleSourceFile.fileName : withoutIndex;
   const kind = withoutIndex === void 0 ? "module" /* moduleElement */ : "directory" /* directory */;
   const indexAfterLastSlash = node.text.lastIndexOf("/") + 1;
   const triggerSpan = createTextSpan(node.getStart(sourceFile) + 1 + indexAfterLastSlash, node.text.length - indexAfterLastSlash);
   return {
     canRename: true,
-    fileToRename: name,
+    fileToRename: fileName,
     kind,
-    displayName: name,
-    fullDisplayName: name,
+    displayName: fileName,
+    fullDisplayName: node.text,
     kindModifiers: "" /* none */,
     triggerSpan
   };
@@ -173461,6 +173589,7 @@ __export(ts_exports2, {
   computeSignature: () => computeSignature,
   computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
   computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
+  computedOptions: () => computedOptions,
   concatenate: () => concatenate,
   concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
   consumesNodeCoreModules: () => consumesNodeCoreModules,
@@ -188255,6 +188384,7 @@ start(initializeNodeSystem(), require("os").platform());
   computeSignature,
   computeSignatureWithDiagnostics,
   computeSuggestionDiagnostics,
+  computedOptions,
   concatenate,
   concatenateDiagnosticMessageChains,
   consumesNodeCoreModules,

package/lib/typescript.d.ts

@@ -1087,6 +1087,7 @@ declare namespace ts {
                 displayName: string;
                 /**
                  * Full display name of item to be renamed.
+                 * If item to be renamed is a file, then this is the original text of the module specifer
                  */
                 fullDisplayName: string;
                 /**
@@ -6831,6 +6832,20 @@ declare namespace ts {
          * is `never`. Instead, use `type.flags & TypeFlags.Never`.
          */
         getNeverType(): Type;
+        /**
+         * Returns true if the "source" type is assignable to the "target" type.
+         *
+         * ```ts
+         * declare const abcLiteral: ts.Type; // Type of "abc"
+         * declare const stringType: ts.Type; // Type of string
+         *
+         * isTypeAssignableTo(abcLiteral, abcLiteral); // true; "abc" is assignable to "abc"
+         * isTypeAssignableTo(abcLiteral, stringType); // true; "abc" is assignable to string
+         * isTypeAssignableTo(stringType, abcLiteral); // false; string is not assignable to "abc"
+         * isTypeAssignableTo(stringType, stringType); // true; string is assignable to string
+         * ```
+         */
+        isTypeAssignableTo(source: Type, target: Type): boolean;
         /**
          * True if this type is the `Array` or `ReadonlyArray` type from lib.d.ts.
          * This function will _not_ return true if passed a type which
@@ -11092,6 +11107,10 @@ declare namespace ts {
          */
         fileToRename?: string;
         displayName: string;
+        /**
+         * Full display name of item to be renamed.
+         * If item to be renamed is a file, then this is the original text of the module specifer
+         */
         fullDisplayName: string;
         kind: ScriptElementKind;
         kindModifiers: string;