typescript 5.5.0-dev.20240408 → 5.5.0-dev.20240410

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240408`;
+var version = `${versionMajorMinor}.0-dev.20240410`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -12934,6 +12934,9 @@ function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
 function isIdentifierTypePredicate(predicate) {
   return predicate && predicate.kind === 1 /* Identifier */;
 }
+function isThisTypePredicate(predicate) {
+  return predicate && predicate.kind === 0 /* This */;
+}
 function forEachPropertyAssignment(objectLiteral, key, callback, key2) {
   return forEach(objectLiteral == null ? void 0 : objectLiteral.properties, (property) => {
     if (!isPropertyAssignment(property))
@@ -13394,6 +13397,9 @@ function getExternalModuleRequireArgument(node) {
 function isInternalModuleImportEqualsDeclaration(node) {
   return node.kind === 271 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 283 /* ExternalModuleReference */;
 }
+function isFullSourceFile(sourceFile) {
+  return (sourceFile == null ? void 0 : sourceFile.kind) === 307 /* SourceFile */;
+}
 function isSourceFileJS(file) {
   return isInJSFile(file);
 }
@@ -17035,12 +17041,12 @@ function getModuleSpecifierEndingPreference(preference, resolutionMode, compiler
     return 1 /* Index */;
   }
   if (!shouldAllowImportingTsExtension(compilerOptions)) {
-    return usesExtensionsOnImports(sourceFile) ? 2 /* JsExtension */ : 0 /* Minimal */;
+    return sourceFile && usesExtensionsOnImports(sourceFile) ? 2 /* JsExtension */ : 0 /* Minimal */;
   }
   return inferPreference();
   function inferPreference() {
     let usesJsExtensions = false;
-    const specifiers = sourceFile.imports.length ? sourceFile.imports : isSourceFileJS(sourceFile) ? getRequiresAtTopOfFile(sourceFile).map((r) => r.arguments[0]) : emptyArray;
+    const specifiers = (sourceFile == null ? void 0 : sourceFile.imports.length) ? sourceFile.imports : sourceFile && isSourceFileJS(sourceFile) ? getRequiresAtTopOfFile(sourceFile).map((r) => r.arguments[0]) : emptyArray;
     for (const specifier of specifiers) {
       if (pathIsRelative(specifier.text)) {
         if (moduleResolutionIsNodeNext && resolutionMode === 1 /* CommonJS */ && getModeForUsageLocation(sourceFile, specifier, compilerOptions) === 99 /* ESNext */) {
@@ -42662,7 +42668,7 @@ function getModuleSpecifierPreferences({ importModuleSpecifierPreference, import
       importModuleSpecifierEnding,
       resolutionMode ?? importingSourceFile.impliedNodeFormat,
       compilerOptions,
-      importingSourceFile
+      isFullSourceFile(importingSourceFile) ? importingSourceFile : void 0
     );
   }
 }
@@ -42722,7 +42728,7 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
 function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
   const info = getInfo(importingSourceFile.fileName, host);
   const preferences = getModuleSpecifierPreferences(userPreferences, compilerOptions, importingSourceFile);
-  const existingSpecifier = forEach(modulePaths, (modulePath) => forEach(
+  const existingSpecifier = isFullSourceFile(importingSourceFile) && forEach(modulePaths, (modulePath) => forEach(
     host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
     (reason) => {
       if (reason.kind !== 3 /* Import */ || reason.file !== importingSourceFile.path)
@@ -48119,7 +48125,7 @@ function createTypeChecker(host) {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
       typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
       expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined)),
+      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
       serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
@@ -48142,6 +48148,18 @@ function createTypeChecker(host) {
       symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
+    function setTextRange2(context, range, location) {
+      if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
+        range = factory.cloneNode(range);
+      }
+      if (!location) {
+        return range;
+      }
+      if (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(location))) {
+        return setOriginalNode(range, location);
+      }
+      return setTextRange(setOriginalNode(range, location), location);
+    }
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
       if (expr) {
         const typeNode = isAssertionExpression(expr) ? expr.type : isJSDocTypeAssertion(expr) ? getJSDocTypeAssertionType(expr) : void 0;
@@ -48206,6 +48224,7 @@ function createTypeChecker(host) {
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
+        enclosingFile: enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration),
         flags: flags || 0 /* None */,
         tracker: void 0,
         encounteredError: false,
@@ -48738,7 +48757,7 @@ function createTypeChecker(host) {
           if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
             return node;
           }
-          return setTextRange(factory.cloneNode(visitEachChild(
+          return setTextRange2(context, factory.cloneNode(visitEachChild(
             node,
             deepCloneOrReuseNode,
             /*context*/
@@ -49080,7 +49099,13 @@ function createTypeChecker(host) {
           context.reverseMappedStack || (context.reverseMappedStack = []);
           context.reverseMappedStack.push(propertySymbol);
         }
-        propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(133 /* AnyKeyword */);
+        propertyTypeNode = propertyType ? serializeTypeForDeclaration(
+          context,
+          /*declaration*/
+          void 0,
+          propertyType,
+          propertySymbol
+        ) : factory.createKeywordTypeNode(133 /* AnyKeyword */);
         if (propertyIsReverseMapped) {
           context.reverseMappedStack.pop();
         }
@@ -49469,8 +49494,7 @@ function createTypeChecker(host) {
     function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
       const parameterType = getTypeOfSymbol(parameterSymbol);
-      const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, addUndefined);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterDeclaration, parameterType, parameterSymbol);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -50062,10 +50086,12 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined) {
+    function serializeTypeForDeclaration(context, declaration, type, symbol) {
       var _a;
+      const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
+      const enclosingDeclaration = context.enclosingDeclaration;
       if (!isErrorType(type) && enclosingDeclaration) {
-        const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
+        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
@@ -50078,7 +50104,7 @@ function createTypeChecker(host) {
       if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
         context.flags |= 1048576 /* AllowUniqueESSymbolType */;
       }
-      const decl = symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
+      const decl = declaration ?? symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
       const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
       const result = expressionOrTypeToTypeNode(context, expr, type, addUndefined);
       context.flags = oldFlags;
@@ -50192,7 +50218,7 @@ function createTypeChecker(host) {
           const type = getDeclaredTypeOfSymbol(sym);
           const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node2);
           name.symbol = sym;
-          return setTextRange(setEmitFlags(setOriginalNode(name, node2), 16777216 /* NoAsciiEscaping */), node2);
+          return setTextRange2(context, setEmitFlags(name, 16777216 /* NoAsciiEscaping */), node2);
         }
         const updated = visitEachChild(
           node2,
@@ -50201,7 +50227,7 @@ function createTypeChecker(host) {
           void 0
         );
         if (updated !== node2) {
-          setTextRange(updated, node2);
+          setTextRange2(context, updated, node2);
         }
         return updated;
       }
@@ -50215,12 +50241,12 @@ function createTypeChecker(host) {
       if (hadError) {
         return void 0;
       }
-      return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
+      return transformed;
       function visitExistingNodeTreeSymbols(node) {
         const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
         const result = visitExistingNodeTreeSymbolsWorker(node);
         onExitNewScope == null ? void 0 : onExitNewScope();
-        return result;
+        return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
       }
       function onEnterNewScope(node) {
         const oldContex = context;
@@ -50356,7 +50382,7 @@ function createTypeChecker(host) {
             void 0
           );
           if (visited === node) {
-            visited = setTextRange(factory.cloneNode(node), node);
+            visited = setTextRange2(context, factory.cloneNode(node), node);
           }
           visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
           if (isParameter(node)) {
@@ -50379,11 +50405,16 @@ function createTypeChecker(host) {
             /*context*/
             void 0
           );
-          const clone = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
+          const clone = setTextRange2(context, visited === node ? factory.cloneNode(node) : visited, node);
           const flags = getEmitFlags(clone);
           setEmitFlags(clone, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
           return clone;
         }
+        if (isStringLiteral(node) && !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */) && !node.singleQuote) {
+          const clone = factory.cloneNode(node);
+          clone.singleQuote = true;
+          return clone;
+        }
         if (isConditionalTypeNode(node)) {
           const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
           const disposeScope = onEnterNewScope(node);
@@ -50762,7 +50793,8 @@ function createTypeChecker(host) {
                 );
                 context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551 /* Value */);
               } else {
-                const statement = setTextRange(
+                const statement = setTextRange2(
+                  context,
                   factory.createVariableStatement(
                     /*modifiers*/
                     void 0,
@@ -50771,7 +50803,13 @@ function createTypeChecker(host) {
                         name,
                         /*exclamationToken*/
                         void 0,
-                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration)
+                        serializeTypeForDeclaration(
+                          context,
+                          /*declaration*/
+                          void 0,
+                          type,
+                          symbol
+                        )
                       )
                     ], flags)
                   ),
@@ -51044,7 +51082,7 @@ function createTypeChecker(host) {
         const signatures = getSignaturesOfType(type, 0 /* Call */);
         for (const sig of signatures) {
           const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName) });
-          addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
+          addResult(setTextRange2(context, decl, getSignatureTextRangeLocation(sig)), modifierFlags);
         }
         if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
           const props = filter(getPropertiesOfType(type), isNamespaceMember);
@@ -51222,7 +51260,8 @@ function createTypeChecker(host) {
         const indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
         context.enclosingDeclaration = oldEnclosing;
         addResult(
-          setTextRange(
+          setTextRange2(
+            context,
             factory.createClassDeclaration(
               /*modifiers*/
               void 0,
@@ -51582,7 +51621,13 @@ function createTypeChecker(host) {
                   varName,
                   /*exclamationToken*/
                   void 0,
-                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration)
+                  serializeTypeForDeclaration(
+                    context,
+                    /*declaration*/
+                    void 0,
+                    typeToSerialize,
+                    symbol
+                  )
                 )
               ], flags)
             );
@@ -51654,7 +51699,8 @@ function createTypeChecker(host) {
               });
               Debug.assert(!!setter);
               const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : void 0;
-              result.push(setTextRange(
+              result.push(setTextRange2(
+                context,
                 factory.createSetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
                   name,
@@ -51666,7 +51712,13 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration)
+                    isPrivate ? void 0 : serializeTypeForDeclaration(
+                      context,
+                      /*declaration*/
+                      void 0,
+                      getTypeOfSymbol(p),
+                      p
+                    )
                   )],
                   /*body*/
                   void 0
@@ -51676,12 +51728,19 @@ function createTypeChecker(host) {
             }
             if (p.flags & 32768 /* GetAccessor */) {
               const isPrivate2 = modifierFlags & 2 /* Private */;
-              result.push(setTextRange(
+              result.push(setTextRange2(
+                context,
                 factory.createGetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
+                  isPrivate2 ? void 0 : serializeTypeForDeclaration(
+                    context,
+                    /*declaration*/
+                    void 0,
+                    getTypeOfSymbol(p),
+                    p
+                  ),
                   /*body*/
                   void 0
                 ),
@@ -51690,12 +51749,19 @@ function createTypeChecker(host) {
             }
             return result;
           } else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
-            return setTextRange(
+            return setTextRange2(
+              context,
               createProperty2(
                 factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration),
+                isPrivate ? void 0 : serializeTypeForDeclaration(
+                  context,
+                  /*declaration*/
+                  void 0,
+                  getWriteTypeOfSymbol(p),
+                  p
+                ),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
@@ -51708,7 +51774,8 @@ function createTypeChecker(host) {
             const type = getTypeOfSymbol(p);
             const signatures = getSignaturesOfType(type, 0 /* Call */);
             if (flag & 2 /* Private */) {
-              return setTextRange(
+              return setTextRange2(
+                context,
                 createProperty2(
                   factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                   name,
@@ -51734,7 +51801,7 @@ function createTypeChecker(host) {
                 }
               );
               const location = sig.declaration && isPrototypePropertyAssignment(sig.declaration.parent) ? sig.declaration.parent : sig.declaration;
-              results2.push(setTextRange(decl, location));
+              results2.push(setTextRange2(context, decl, location));
             }
             return results2;
           }
@@ -51790,7 +51857,8 @@ function createTypeChecker(host) {
             }
           }
           if (privateProtected) {
-            return [setTextRange(
+            return [setTextRange2(
+              context,
               factory.createConstructorDeclaration(
                 factory.createModifiersFromModifierFlags(privateProtected),
                 /*parameters*/
@@ -51805,7 +51873,7 @@ function createTypeChecker(host) {
         const results2 = [];
         for (const sig of signatures) {
           const decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
-          results2.push(setTextRange(decl, sig.declaration));
+          results2.push(setTextRange2(context, decl, sig.declaration));
         }
         return results2;
       }
@@ -55488,12 +55556,10 @@ function createTypeChecker(host) {
     const target = type.target ?? type;
     const typeVariable = getHomomorphicTypeVariable(target);
     if (typeVariable && !target.declaration.nameType) {
-      const constraint = getConstraintTypeFromMappedType(type);
-      if (constraint.flags & 4194304 /* Index */) {
-        const baseConstraint = getBaseConstraintOfType(constraint.type);
-        if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
-          return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
-        }
+      const modifiersType = getModifiersTypeFromMappedType(type);
+      const baseConstraint = isGenericMappedType(modifiersType) ? getApparentTypeOfMappedType(modifiersType) : getBaseConstraintOfType(modifiersType);
+      if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
+        return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
       }
     }
     return type;
@@ -55654,13 +55720,13 @@ function createTypeChecker(host) {
   }
   function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
     var _a, _b, _c;
-    let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
+    let property = skipObjectFunctionPropertyAugment ? (_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name) : (_b = type.propertyCache) == null ? void 0 : _b.get(name);
     if (!property) {
       property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
       if (property) {
         const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
         properties.set(name, property);
-        if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+        if (skipObjectFunctionPropertyAugment && !(getCheckFlags(property) & 48 /* Partial */) && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
           const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
           properties2.set(name, property);
         }
@@ -60923,7 +60989,7 @@ function createTypeChecker(host) {
         const sourceTypePredicate = getTypePredicateOfSignature(source);
         if (sourceTypePredicate) {
           result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors2, errorReporter, compareTypes);
-        } else if (isIdentifierTypePredicate(targetTypePredicate)) {
+        } else if (isIdentifierTypePredicate(targetTypePredicate) || isThisTypePredicate(targetTypePredicate)) {
           if (reportErrors2) {
             errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
           }
@@ -83307,9 +83373,10 @@ function createTypeChecker(host) {
     return false;
   }
   function declaredParameterTypeContainsUndefined(parameter) {
-    if (!parameter.type)
+    const typeNode = getNonlocalEffectiveTypeAnnotationNode(parameter);
+    if (!typeNode)
       return false;
-    const type = getTypeFromTypeNode(parameter.type);
+    const type = getTypeFromTypeNode(typeNode);
     return containsUndefinedType(type);
   }
   function requiresAddingImplicitUndefined(parameter) {
@@ -83319,7 +83386,7 @@ function createTypeChecker(host) {
     return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isOptionalUninitializedParameterProperty(parameter) {
-    return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
+    return strictNullChecks && isOptionalParameter(parameter) && (isJSDocParameterTag(parameter) || !parameter.initializer) && hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isExpandoFunctionDeclaration(node) {
     const declaration = getParseTreeNode(node, isFunctionDeclaration);
@@ -83469,14 +83536,14 @@ function createTypeChecker(host) {
       return 11 /* ObjectType */;
     }
   }
-  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) {
+  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker) {
     const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
     if (!declaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
     const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    return nodeBuilder.serializeTypeForDeclaration(type, symbol, addUndefined, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
@@ -109129,7 +109196,7 @@ function transformDeclarations(context) {
       case 172 /* PropertyDeclaration */:
       case 208 /* BindingElement */:
       case 260 /* VariableDeclaration */:
-        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
         break;
       case 262 /* FunctionDeclaration */:
       case 180 /* ConstructSignature */:

package/lib/typescript.d.ts

@@ -3233,7 +3233,6 @@ declare namespace ts {
             private addFilesToNonInferredProject;
             private updateNonInferredProjectFiles;
             private updateRootAndOptionsOfNonInferredProject;
-            private sendConfigFileDiagEvent;
             private getOrCreateInferredProjectForProjectRootPathIfEnabled;
             private getOrCreateSingleInferredProjectIfEnabled;
             private getOrCreateSingleInferredWithoutProjectRoot;