typescript 4.8.0-dev.20220509 → 4.8.0-dev.20220512

package/lib/typescript.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220509";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220512";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8336,6 +8336,7 @@ var ts;
         String_literal_expected: diag(1141, ts.DiagnosticCategory.Error, "String_literal_expected_1141", "String literal expected."),
         Line_break_not_permitted_here: diag(1142, ts.DiagnosticCategory.Error, "Line_break_not_permitted_here_1142", "Line break not permitted here."),
         or_expected: diag(1144, ts.DiagnosticCategory.Error, "or_expected_1144", "'{' or ';' expected."),
+        or_JSX_element_expected: diag(1145, ts.DiagnosticCategory.Error, "or_JSX_element_expected_1145", "'{' or JSX element expected."),
         Declaration_expected: diag(1146, ts.DiagnosticCategory.Error, "Declaration_expected_1146", "Declaration expected."),
         Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, ts.DiagnosticCategory.Error, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."),
         Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: diag(1148, ts.DiagnosticCategory.Error, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."),
@@ -8588,6 +8589,7 @@ var ts;
         resolution_mode_can_only_be_set_for_type_only_imports: diag(1454, ts.DiagnosticCategory.Error, "resolution_mode_can_only_be_set_for_type_only_imports_1454", "`resolution-mode` can only be set for type-only imports."),
         resolution_mode_is_the_only_valid_key_for_type_import_assertions: diag(1455, ts.DiagnosticCategory.Error, "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455", "`resolution-mode` is the only valid key for type import assertions."),
         Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require: diag(1456, ts.DiagnosticCategory.Error, "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456", "Type import assertions should have exactly one key - `resolution-mode` - with value `import` or `require`."),
+        Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk: diag(1457, ts.DiagnosticCategory.Message, "Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk_1457", "Matched by default include pattern '**/*'"),
         The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
         Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead."),
         catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
@@ -14267,6 +14269,16 @@ var ts;
         return node.kind === 324 /* JSDocLink */ || node.kind === 325 /* JSDocLinkCode */ || node.kind === 326 /* JSDocLinkPlain */;
     }
     ts.isJSDocLinkLike = isJSDocLinkLike;
+    function hasRestParameter(s) {
+        var last = ts.lastOrUndefined(s.parameters);
+        return !!last && isRestParameter(last);
+    }
+    ts.hasRestParameter = hasRestParameter;
+    function isRestParameter(node) {
+        var type = ts.isJSDocParameterTag(node) ? (node.typeExpression && node.typeExpression.type) : node.type;
+        return node.dotDotDotToken !== undefined || !!type && type.kind === 318 /* JSDocVariadicType */;
+    }
+    ts.isRestParameter = isRestParameter;
     // #endregion
 })(ts || (ts = {}));
 /* @internal */
@@ -17037,16 +17049,6 @@ var ts;
         return typeParameters && ts.find(typeParameters, function (p) { return p.name.escapedText === name; });
     }
     ts.getTypeParameterFromJsDoc = getTypeParameterFromJsDoc;
-    function hasRestParameter(s) {
-        var last = ts.lastOrUndefined(s.parameters);
-        return !!last && isRestParameter(last);
-    }
-    ts.hasRestParameter = hasRestParameter;
-    function isRestParameter(node) {
-        var type = ts.isJSDocParameterTag(node) ? (node.typeExpression && node.typeExpression.type) : node.type;
-        return node.dotDotDotToken !== undefined || !!type && type.kind === 318 /* JSDocVariadicType */;
-    }
-    ts.isRestParameter = isRestParameter;
     function hasTypeArguments(node) {
         return !!node.typeArguments;
     }
@@ -34576,6 +34578,10 @@ var ts;
                 // isn't actually allowed, but we want to treat it as a lambda so we can provide
                 // a good error message.
                 if (ts.isModifierKind(second) && second !== 131 /* AsyncKeyword */ && lookAhead(nextTokenIsIdentifier)) {
+                    if (nextToken() === 127 /* AsKeyword */) {
+                        // https://github.com/microsoft/TypeScript/issues/44466
+                        return 0 /* False */;
+                    }
                     return 1 /* True */;
                 }
                 // If we had "(" followed by something that's not an identifier,
@@ -35391,9 +35397,22 @@ var ts;
             }
             scanJsxIdentifier();
             var pos = getNodePos();
-            return finishNode(factory.createJsxAttribute(parseIdentifierName(), token() !== 63 /* EqualsToken */ ? undefined :
-                scanJsxAttributeValue() === 10 /* StringLiteral */ ? parseLiteralNode() :
-                    parseJsxExpression(/*inExpressionContext*/ true)), pos);
+            return finishNode(factory.createJsxAttribute(parseIdentifierName(), parseJsxAttributeValue()), pos);
+        }
+        function parseJsxAttributeValue() {
+            if (token() === 63 /* EqualsToken */) {
+                if (scanJsxAttributeValue() === 10 /* StringLiteral */) {
+                    return parseLiteralNode();
+                }
+                if (token() === 18 /* OpenBraceToken */) {
+                    return parseJsxExpression(/*inExpressionContext*/ true);
+                }
+                if (token() === 29 /* LessThanToken */) {
+                    return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true);
+                }
+                parseErrorAtCurrentToken(ts.Diagnostics.or_JSX_element_expected);
+            }
+            return undefined;
         }
         function parseJsxSpreadAttribute() {
             var pos = getNodePos();
@@ -41165,7 +41184,7 @@ var ts;
             return undefined;
         if (ts.length(specs) !== 1)
             return specs;
-        if (specs[0] === "**/*")
+        if (specs[0] === ts.defaultIncludeSpec)
             return undefined;
         return specs;
     }
@@ -41443,6 +41462,8 @@ var ts;
         // until consistent casing errors are reported
         return ts.getDirectoryPath(ts.getNormalizedAbsolutePath(fileName, basePath));
     }
+    /*@internal*/
+    ts.defaultIncludeSpec = "**/*";
     /**
      * Parse the contents of a config file from json or json source file (tsconfig.json).
      * @param json The contents of the config file to parse
@@ -41508,6 +41529,7 @@ var ts;
             }
             var includeSpecs = toPropValue(getSpecsFromRaw("include"));
             var excludeOfRaw = getSpecsFromRaw("exclude");
+            var isDefaultIncludeSpec = false;
             var excludeSpecs = toPropValue(excludeOfRaw);
             if (excludeOfRaw === "no-prop" && raw.compilerOptions) {
                 var outDir = raw.compilerOptions.outDir;
@@ -41517,7 +41539,8 @@ var ts;
                 }
             }
             if (filesSpecs === undefined && includeSpecs === undefined) {
-                includeSpecs = ["**/*"];
+                includeSpecs = [ts.defaultIncludeSpec];
+                isDefaultIncludeSpec = true;
             }
             var validatedIncludeSpecs, validatedExcludeSpecs;
             // The exclude spec list is converted into a regular expression, which allows us to quickly
@@ -41536,7 +41559,8 @@ var ts;
                 validatedFilesSpec: ts.filter(filesSpecs, ts.isString),
                 validatedIncludeSpecs: validatedIncludeSpecs,
                 validatedExcludeSpecs: validatedExcludeSpecs,
-                pathPatterns: undefined, // Initialized on first use
+                pathPatterns: undefined,
+                isDefaultIncludeSpec: isDefaultIncludeSpec,
             };
         }
         function getFileNames(basePath) {
@@ -51661,8 +51685,9 @@ var ts;
         function getExportSymbolOfValueSymbolIfExported(symbol) {
             return getMergedSymbol(symbol && (symbol.flags & 1048576 /* ExportValue */) !== 0 && symbol.exportSymbol || symbol);
         }
-        function symbolIsValue(symbol) {
-            return !!(symbol.flags & 111551 /* Value */ || symbol.flags & 2097152 /* Alias */ && resolveAlias(symbol).flags & 111551 /* Value */ && !getTypeOnlyAliasDeclaration(symbol));
+        function symbolIsValue(symbol, includeTypeOnlyMembers) {
+            return !!(symbol.flags & 111551 /* Value */ ||
+                symbol.flags & 2097152 /* Alias */ && resolveAlias(symbol).flags & 111551 /* Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
@@ -59352,12 +59377,12 @@ var ts;
          * @param type a type to look up property from
          * @param name a name of property to look up in a given type
          */
-        function getPropertyOfType(type, name, skipObjectFunctionPropertyAugment) {
+        function getPropertyOfType(type, name, skipObjectFunctionPropertyAugment, includeTypeOnlyMembers) {
             type = getReducedApparentType(type);
             if (type.flags & 524288 /* Object */) {
                 var resolved = resolveStructuredTypeMembers(type);
                 var symbol = resolved.members.get(name);
-                if (symbol && symbolIsValue(symbol)) {
+                if (symbol && symbolIsValue(symbol, includeTypeOnlyMembers)) {
                     return symbol;
                 }
                 if (skipObjectFunctionPropertyAugment)
@@ -62737,7 +62762,7 @@ var ts;
                         // the `exports` lookup process that only looks up namespace members which is used for most type references
                         var mergedResolvedSymbol = getMergedSymbol(resolveSymbol(currentNamespace));
                         var next = node.isTypeOf
-                            ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText)
+                            ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText, /*skipObjectFunctionPropertyAugment*/ false, /*includeTypeOnlyMembers*/ true)
                             : getSymbol(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning);
                         if (!next) {
                             error(current, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), ts.declarationNameToString(current));
@@ -65659,6 +65684,20 @@ var ts;
                             }
                         }
                     }
+                    if (relation === comparableRelation && sourceFlags & 262144 /* TypeParameter */) {
+                        // This is a carve-out in comparability to essentially forbid comparing a type parameter
+                        // with another type parameter unless one extends the other. (Remember: comparability is mostly bidirectional!)
+                        var constraint = getConstraintOfTypeParameter(source);
+                        if (constraint && hasNonCircularBaseConstraint(source)) {
+                            while (constraint && constraint.flags & 262144 /* TypeParameter */) {
+                                if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false)) {
+                                    return result;
+                                }
+                                constraint = getConstraintOfTypeParameter(constraint);
+                            }
+                        }
+                        return 0 /* False */;
+                    }
                 }
                 else if (targetFlags & 4194304 /* Index */) {
                     var targetType_1 = target.type;
@@ -65862,8 +65901,8 @@ var ts;
                 if (sourceFlags & 8650752 /* TypeVariable */) {
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
-                        var constraint = getConstraintOfType(source);
-                        if (!constraint || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
+                        var constraint = getConstraintOfType(source) || unknownType;
+                        if (!getConstraintOfType(source) || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
                             // A type variable with no constraint is not related to the non-primitive object type.
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
                                 resetErrorInfo(saveErrorInfo);
@@ -65871,12 +65910,12 @@ var ts;
                             }
                         }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
-                        else if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                        if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
+                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -72713,7 +72752,25 @@ var ts;
         }
         function getTypeOfPropertyOfContextualType(type, name, nameType) {
             return mapType(type, function (t) {
-                var _a;
+                if (t.flags & 2097152 /* Intersection */) {
+                    var intersection = t;
+                    var newTypes = ts.mapDefined(intersection.types, getTypeOfConcretePropertyOfContextualType);
+                    if (newTypes.length > 0) {
+                        return getIntersectionType(newTypes);
+                    }
+                    newTypes = ts.mapDefined(intersection.types, getTypeOfApplicableIndexInfoOfContextualType);
+                    if (newTypes.length > 0) {
+                        return getIntersectionType(newTypes);
+                    }
+                    return undefined;
+                }
+                var concretePropertyType = getTypeOfConcretePropertyOfContextualType(t);
+                if (concretePropertyType) {
+                    return concretePropertyType;
+                }
+                return getTypeOfApplicableIndexInfoOfContextualType(t);
+            }, /*noReductions*/ true);
+            function getTypeOfConcretePropertyOfContextualType(t) {
                 if (isGenericMappedType(t) && !t.declaration.nameType) {
                     var constraint = getConstraintTypeFromMappedType(t);
                     var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
@@ -72721,8 +72778,9 @@ var ts;
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
+                    return undefined;
                 }
-                else if (t.flags & 3670016 /* StructuredType */) {
+                if (t.flags & 3670016 /* StructuredType */) {
                     var prop = getPropertyOfType(t, name);
                     if (prop) {
                         return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop);
@@ -72733,10 +72791,16 @@ var ts;
                             return restType;
                         }
                     }
-                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
                 }
                 return undefined;
-            }, /*noReductions*/ true);
+            }
+            function getTypeOfApplicableIndexInfoOfContextualType(t) {
+                var _a;
+                if (!(t.flags & 3670016 /* StructuredType */)) {
+                    return undefined;
+                }
+                return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
+            }
         }
         // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of
         // the matching property in T, if one exists. Otherwise, it is the type of the numeric index signature in T, if one
@@ -74614,9 +74678,8 @@ var ts;
                         markAliasReferenced(parentSymbol, node);
                     }
                     return isErrorType(apparentType) ? errorType : apparentType;
-                    ;
                 }
-                prop = getPropertyOfType(apparentType, right.escapedText);
+                prop = getPropertyOfType(apparentType, right.escapedText, /*skipObjectFunctionPropertyAugment*/ false, /*includeTypeOnlyMembers*/ node.kind === 161 /* QualifiedName */);
             }
             // In `Foo.Bar.Baz`, 'Foo' is not referenced if 'Bar' is a const enum or a module containing only const enums.
             // `Foo` is also not referenced in `enum FooCopy { Bar = Foo.Bar }`, because the enum member value gets inlined
@@ -81210,7 +81273,7 @@ var ts;
          * @param type The type of the promise.
          * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback.
          */
-        function getPromisedTypeOfPromise(type, errorNode) {
+        function getPromisedTypeOfPromise(type, errorNode, thisTypeForErrorOut) {
             //
             //  { // type
             //      then( // thenFunction
@@ -81245,7 +81308,29 @@ var ts;
                 }
                 return undefined;
             }
-            var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(thenSignatures, getTypeOfFirstParameterOfSignature)), 2097152 /* NEUndefinedOrNull */);
+            var thisTypeForError;
+            var candidates;
+            for (var _i = 0, thenSignatures_1 = thenSignatures; _i < thenSignatures_1.length; _i++) {
+                var thenSignature = thenSignatures_1[_i];
+                var thisType = getThisTypeOfSignature(thenSignature);
+                if (thisType && thisType !== voidType && !isTypeRelatedTo(type, thisType, subtypeRelation)) {
+                    thisTypeForError = thisType;
+                }
+                else {
+                    candidates = ts.append(candidates, thenSignature);
+                }
+            }
+            if (!candidates) {
+                ts.Debug.assertIsDefined(thisTypeForError);
+                if (thisTypeForErrorOut) {
+                    thisTypeForErrorOut.value = thisTypeForError;
+                }
+                if (errorNode) {
+                    error(errorNode, ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForError));
+                }
+                return undefined;
+            }
+            var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(candidates, getTypeOfFirstParameterOfSignature)), 2097152 /* NEUndefinedOrNull */);
             if (isTypeAny(onfulfilledParameterType)) {
                 return undefined;
             }
@@ -81369,7 +81454,8 @@ var ts;
                 var mapper = errorNode ? function (constituentType) { return getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, arg0); } : getAwaitedTypeNoAlias;
                 return typeAsAwaitable.awaitedTypeOfType = mapType(type, mapper);
             }
-            var promisedType = getPromisedTypeOfPromise(type);
+            var thisTypeForErrorOut = { value: undefined };
+            var promisedType = getPromisedTypeOfPromise(type, /*errorNode*/ undefined, thisTypeForErrorOut);
             if (promisedType) {
                 if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 0) {
                     // Verify that we don't have a bad actor in the form of a promise whose
@@ -81438,7 +81524,12 @@ var ts;
             if (isThenableType(type)) {
                 if (errorNode) {
                     ts.Debug.assertIsDefined(diagnosticMessage);
-                    error(errorNode, diagnosticMessage, arg0);
+                    var chain = void 0;
+                    if (thisTypeForErrorOut.value) {
+                        chain = ts.chainDiagnosticMessages(chain, ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForErrorOut.value));
+                    }
+                    chain = ts.chainDiagnosticMessages(chain, diagnosticMessage, arg0);
+                    diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, chain));
                 }
                 return undefined;
             }
@@ -97926,22 +98017,29 @@ var ts;
             if (node === undefined) {
                 return factory.createTrue();
             }
-            else if (node.kind === 10 /* StringLiteral */) {
+            if (node.kind === 10 /* StringLiteral */) {
                 // Always recreate the literal to escape any escape sequences or newlines which may be in the original jsx string and which
                 // Need to be escaped to be handled correctly in a normal string
                 var singleQuote = node.singleQuote !== undefined ? node.singleQuote : !ts.isStringDoubleQuoted(node, currentSourceFile);
                 var literal = factory.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote);
                 return ts.setTextRange(literal, node);
             }
-            else if (node.kind === 288 /* JsxExpression */) {
+            if (node.kind === 288 /* JsxExpression */) {
                 if (node.expression === undefined) {
                     return factory.createTrue();
                 }
                 return ts.visitNode(node.expression, visitor, ts.isExpression);
             }
-            else {
-                return ts.Debug.failBadSyntaxKind(node);
+            if (ts.isJsxElement(node)) {
+                return visitJsxElement(node, /*isChild*/ false);
+            }
+            if (ts.isJsxSelfClosingElement(node)) {
+                return visitJsxSelfClosingElement(node, /*isChild*/ false);
             }
+            if (ts.isJsxFragment(node)) {
+                return visitJsxFragment(node, /*isChild*/ false);
+            }
+            return ts.Debug.failBadSyntaxKind(node);
         }
         function visitJsxText(node) {
             var fixed = fixupWhitespaceAndDecodeEntities(node.text);
@@ -118956,7 +119054,7 @@ var ts;
                     }
                     var matchedByInclude = ts.getMatchedIncludeSpec(program, fileName);
                     // Could be additional files specified as roots
-                    if (!matchedByInclude)
+                    if (!matchedByInclude || !ts.isString(matchedByInclude))
                         return undefined;
                     configFileNode = ts.getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude);
                     message = ts.Diagnostics.File_is_matched_by_include_pattern_specified_here;
@@ -122554,6 +122652,8 @@ var ts;
             if (ts.fileExtensionIsOneOf(fileName, [".json" /* Json */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]))
                 return fileName;
             var noExtension = ts.removeFileExtension(fileName);
+            if (fileName === noExtension)
+                return fileName;
             if (ts.fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".d.cts" /* Dcts */, ".cts" /* Cts */]))
                 return noExtension + getJSExtensionForFile(fileName, options);
             switch (ending) {
@@ -122842,6 +122942,9 @@ var ts;
         var configFile = program.getCompilerOptions().configFile;
         if (!((_a = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _a === void 0 ? void 0 : _a.validatedIncludeSpecs))
             return undefined;
+        // Return true if its default include spec
+        if (configFile.configFileSpecs.isDefaultIncludeSpec)
+            return true;
         var isJsonFile = ts.fileExtensionIs(fileName, ".json" /* Json */);
         var basePath = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
         var useCaseSensitiveFileNames = program.useCaseSensitiveFileNames();
@@ -122907,11 +123010,13 @@ var ts;
                 if (matchedByFiles)
                     return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Part_of_files_list_in_tsconfig_json);
                 var matchedByInclude = getMatchedIncludeSpec(program, fileName);
-                return matchedByInclude ?
+                return ts.isString(matchedByInclude) ?
                     ts.chainDiagnosticMessages(
                     /*details*/ undefined, ts.Diagnostics.Matched_by_include_pattern_0_in_1, matchedByInclude, toFileName(options.configFile, fileNameConvertor)) :
-                    // Could be additional files specified as roots
-                    ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Root_file_specified_for_compilation);
+                    // Could be additional files specified as roots or matched by default include
+                    ts.chainDiagnosticMessages(/*details*/ undefined, matchedByInclude ?
+                        ts.Diagnostics.Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk :
+                        ts.Diagnostics.Root_file_specified_for_compilation);
             case ts.FileIncludeKind.SourceFromProjectReference:
             case ts.FileIncludeKind.OutputFromProjectReference:
                 var isOutput = reason.kind === ts.FileIncludeKind.OutputFromProjectReference;
@@ -127045,6 +127150,8 @@ var ts;
                 case 256 /* FunctionDeclaration */:
                 case 213 /* FunctionExpression */:
                     return getAdjustedLocationForFunction(node);
+                case 171 /* Constructor */:
+                    return node;
             }
         }
         if (ts.isNamedDeclaration(node)) {
@@ -140143,11 +140250,12 @@ var ts;
             ts.forEachUnique(declarations, function (declaration) {
                 for (var _i = 0, _a = getCommentHavingNodes(declaration); _i < _a.length; _i++) {
                     var jsdoc = _a[_i];
+                    var inheritDoc = ts.isJSDoc(jsdoc) && jsdoc.tags && ts.find(jsdoc.tags, function (t) { return t.kind === 327 /* JSDocTag */ && (t.tagName.escapedText === "inheritDoc" || t.tagName.escapedText === "inheritdoc"); });
                     // skip comments containing @typedefs since they're not associated with particular declarations
                     // Exceptions:
                     // - @typedefs are themselves declarations with associated comments
                     // - @param or @return indicate that the author thinks of it as a 'local' @typedef that's part of the function documentation
-                    if (jsdoc.comment === undefined
+                    if (jsdoc.comment === undefined && !inheritDoc
                         || ts.isJSDoc(jsdoc)
                             && declaration.kind !== 345 /* JSDocTypedefTag */ && declaration.kind !== 338 /* JSDocCallbackTag */
                             && jsdoc.tags
@@ -140155,7 +140263,10 @@ var ts;
                             && !jsdoc.tags.some(function (t) { return t.kind === 340 /* JSDocParameterTag */ || t.kind === 341 /* JSDocReturnTag */; })) {
                         continue;
                     }
-                    var newparts = getDisplayPartsFromComment(jsdoc.comment, checker);
+                    var newparts = jsdoc.comment ? getDisplayPartsFromComment(jsdoc.comment, checker) : [];
+                    if (inheritDoc && inheritDoc.comment) {
+                        newparts = newparts.concat(getDisplayPartsFromComment(inheritDoc.comment, checker));
+                    }
                     if (!ts.contains(parts, newparts, isIdenticalListOfDisplayParts)) {
                         parts.push(newparts);
                     }
@@ -154911,6 +155022,7 @@ var ts;
             var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
             var functionDeclaration = codefix.createSignatureDeclarationFromCallExpression(256 /* FunctionDeclaration */, context, importAdder, info.call, ts.idText(info.token), info.modifierFlags, info.parentDeclaration);
             changes.insertNodeAtEndOfScope(info.sourceFile, info.parentDeclaration, functionDeclaration);
+            importAdder.writeFixes(changes);
         }
         function addJsxAttributes(changes, context, info) {
             var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
@@ -154919,7 +155031,7 @@ var ts;
             var jsxAttributesNode = info.parentDeclaration.attributes;
             var hasSpreadAttribute = ts.some(jsxAttributesNode.properties, ts.isJsxSpreadAttribute);
             var attrs = ts.map(info.attributes, function (attr) {
-                var value = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(attr));
+                var value = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(attr), info.parentDeclaration);
                 var name = ts.factory.createIdentifier(attr.name);
                 var jsxAttribute = ts.factory.createJsxAttribute(name, ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, value));
                 // formattingScanner requires the Identifier to have a context for scanning attributes with "-" (data-foo).
@@ -154929,6 +155041,7 @@ var ts;
             var jsxAttributes = ts.factory.createJsxAttributes(hasSpreadAttribute ? __spreadArray(__spreadArray([], attrs, true), jsxAttributesNode.properties, true) : __spreadArray(__spreadArray([], jsxAttributesNode.properties, true), attrs, true));
             var options = { prefix: jsxAttributesNode.pos === jsxAttributesNode.end ? " " : undefined };
             changes.replaceNode(context.sourceFile, jsxAttributesNode, jsxAttributes, options);
+            importAdder.writeFixes(changes);
         }
         function addObjectLiteralProperties(changes, context, info) {
             var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
@@ -154936,7 +155049,7 @@ var ts;
             var target = ts.getEmitScriptTarget(context.program.getCompilerOptions());
             var checker = context.program.getTypeChecker();
             var props = ts.map(info.properties, function (prop) {
-                var initializer = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(prop));
+                var initializer = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(prop), info.parentDeclaration);
                 return ts.factory.createPropertyAssignment(ts.createPropertyNameNodeForIdentifierOrLiteral(prop.name, target, quotePreference === 0 /* Single */), initializer);
             });
             var options = {
@@ -154945,8 +155058,9 @@ var ts;
                 indentation: info.indentation
             };
             changes.replaceNode(context.sourceFile, info.parentDeclaration, ts.factory.createObjectLiteralExpression(__spreadArray(__spreadArray([], info.parentDeclaration.properties, true), props, true), /*multiLine*/ true), options);
+            importAdder.writeFixes(changes);
         }
-        function tryGetValueFromType(context, checker, importAdder, quotePreference, type) {
+        function tryGetValueFromType(context, checker, importAdder, quotePreference, type, enclosingDeclaration) {
             if (type.flags & 3 /* AnyOrUnknown */) {
                 return createUndefined();
             }
@@ -154983,7 +155097,7 @@ var ts;
                 return ts.factory.createNull();
             }
             if (type.flags & 1048576 /* Union */) {
-                var expression = ts.firstDefined(type.types, function (t) { return tryGetValueFromType(context, checker, importAdder, quotePreference, t); });
+                var expression = ts.firstDefined(type.types, function (t) { return tryGetValueFromType(context, checker, importAdder, quotePreference, t, enclosingDeclaration); });
                 return expression !== null && expression !== void 0 ? expression : createUndefined();
             }
             if (checker.isArrayLikeType(type)) {
@@ -154991,7 +155105,7 @@ var ts;
             }
             if (isObjectLiteralType(type)) {
                 var props = ts.map(checker.getPropertiesOfType(type), function (prop) {
-                    var initializer = prop.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(prop.valueDeclaration)) : createUndefined();
+                    var initializer = prop.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(prop.valueDeclaration), enclosingDeclaration) : createUndefined();
                     return ts.factory.createPropertyAssignment(prop.name, initializer);
                 });
                 return ts.factory.createObjectLiteralExpression(props, /*multiLine*/ true);
@@ -155003,7 +155117,7 @@ var ts;
                 var signature = checker.getSignaturesOfType(type, 0 /* Call */);
                 if (signature === undefined)
                     return createUndefined();
-                var func = codefix.createSignatureDeclarationFromSignature(213 /* FunctionExpression */, context, quotePreference, signature[0], codefix.createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference), /*name*/ undefined, /*modifiers*/ undefined, /*optional*/ undefined, /*enclosingDeclaration*/ undefined, importAdder);
+                var func = codefix.createSignatureDeclarationFromSignature(213 /* FunctionExpression */, context, quotePreference, signature[0], codefix.createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference), /*name*/ undefined, /*modifiers*/ undefined, /*optional*/ undefined, /*enclosingDeclaration*/ enclosingDeclaration, importAdder);
                 return func !== null && func !== void 0 ? func : createUndefined();
             }
             if (ts.getObjectFlags(type) & 1 /* Class */) {
@@ -164290,7 +164404,7 @@ var ts;
      * @returns `true` if `node` has a JSDoc "inheritDoc" tag on it, otherwise `false`.
      */
     function hasJSDocInheritDocTag(node) {
-        return ts.getJSDocTags(node).some(function (tag) { return tag.tagName.text === "inheritDoc"; });
+        return ts.getJSDocTags(node).some(function (tag) { return tag.tagName.text === "inheritDoc" || tag.tagName.text === "inheritdoc"; });
     }
     function getJsDocTagsOfDeclarations(declarations, checker) {
         if (!declarations)
@@ -164349,13 +164463,15 @@ var ts;
     }
     function findBaseOfDeclaration(checker, declaration, cb) {
         var _a;
-        if (ts.hasStaticModifier(declaration))
-            return;
         var classOrInterfaceDeclaration = ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.kind) === 171 /* Constructor */ ? declaration.parent.parent : declaration.parent;
         if (!classOrInterfaceDeclaration)
             return;
+        var isStaticMember = ts.hasStaticModifier(declaration);
         return ts.firstDefined(ts.getAllSuperTypeNodes(classOrInterfaceDeclaration), function (superTypeNode) {
-            var symbol = checker.getPropertyOfType(checker.getTypeAtLocation(superTypeNode), declaration.symbol.name);
+            var baseType = checker.getTypeAtLocation(superTypeNode);
+            var symbol = isStaticMember
+                ? ts.find(checker.getExportsOfModule(baseType.symbol), function (s) { return s.escapedName === declaration.symbol.name; })
+                : checker.getPropertyOfType(baseType, declaration.symbol.name);
             return symbol ? cb(symbol) : undefined;
         });
     }

package/lib/typescriptServices.d.ts

@@ -1388,8 +1388,9 @@ declare namespace ts {
         readonly kind: SyntaxKind.JsxAttribute;
         readonly parent: JsxAttributes;
         readonly name: Identifier;
-        readonly initializer?: StringLiteral | JsxExpression;
+        readonly initializer?: JsxAttributeValue;
     }
+    export type JsxAttributeValue = StringLiteral | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
     export interface JsxSpreadAttribute extends ObjectLiteralElement {
         readonly kind: SyntaxKind.JsxSpreadAttribute;
         readonly parent: JsxAttributes;
@@ -3746,8 +3747,8 @@ declare namespace ts {
         createJsxOpeningFragment(): JsxOpeningFragment;
         createJsxJsxClosingFragment(): JsxClosingFragment;
         updateJsxFragment(node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
-        createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression | undefined): JsxAttribute;
-        updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression | undefined): JsxAttribute;
+        createJsxAttribute(name: Identifier, initializer: JsxAttributeValue | undefined): JsxAttribute;
+        updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: JsxAttributeValue | undefined): JsxAttribute;
         createJsxAttributes(properties: readonly JsxAttributeLike[]): JsxAttributes;
         updateJsxAttributes(node: JsxAttributes, properties: readonly JsxAttributeLike[]): JsxAttributes;
         createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute;
@@ -4510,6 +4511,8 @@ declare namespace ts {
     function isObjectLiteralElement(node: Node): node is ObjectLiteralElement;
     function isStringLiteralLike(node: Node): node is StringLiteralLike;
     function isJSDocLinkLike(node: Node): node is JSDocLink | JSDocLinkCode | JSDocLinkPlain;
+    function hasRestParameter(s: SignatureDeclaration | JSDocSignature): boolean;
+    function isRestParameter(node: ParameterDeclaration | JSDocParameterTag): boolean;
 }
 declare namespace ts {
     const factory: NodeFactory;
@@ -7479,9 +7482,9 @@ declare namespace ts {
     /** @deprecated Use `factory.updateJsxFragment` or the factory supplied by your transformation context instead. */
     const updateJsxFragment: (node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment) => JsxFragment;
     /** @deprecated Use `factory.createJsxAttribute` or the factory supplied by your transformation context instead. */
-    const createJsxAttribute: (name: Identifier, initializer: StringLiteral | JsxExpression | undefined) => JsxAttribute;
+    const createJsxAttribute: (name: Identifier, initializer: JsxAttributeValue | undefined) => JsxAttribute;
     /** @deprecated Use `factory.updateJsxAttribute` or the factory supplied by your transformation context instead. */
-    const updateJsxAttribute: (node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression | undefined) => JsxAttribute;
+    const updateJsxAttribute: (node: JsxAttribute, name: Identifier, initializer: JsxAttributeValue | undefined) => JsxAttribute;
     /** @deprecated Use `factory.createJsxAttributes` or the factory supplied by your transformation context instead. */
     const createJsxAttributes: (properties: readonly JsxAttributeLike[]) => JsxAttributes;
     /** @deprecated Use `factory.updateJsxAttributes` or the factory supplied by your transformation context instead. */