typescript 4.8.0-dev.20220507 → 4.8.0-dev.20220510

package/lib/tsserver.js

@@ -100,7 +100,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.20220507";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220510";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -14073,6 +14073,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 */
@@ -16843,16 +16853,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;
     }
@@ -65465,6 +65465,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;
@@ -65668,8 +65682,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);
@@ -65677,12 +65691,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;
                         }
@@ -72519,7 +72533,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;
@@ -72527,8 +72559,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);
@@ -72539,10 +72572,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
@@ -81016,7 +81055,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
@@ -81051,7 +81090,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;
             }
@@ -81175,7 +81236,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
@@ -81244,7 +81306,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;
             }
@@ -122360,6 +122427,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) {
@@ -126434,6 +126503,8 @@ var ts;
                 case 256 /* FunctionDeclaration */:
                 case 213 /* FunctionExpression */:
                     return getAdjustedLocationForFunction(node);
+                case 171 /* Constructor */:
+                    return node;
             }
         }
         if (ts.isNamedDeclaration(node)) {
@@ -139532,11 +139603,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
@@ -139544,7 +139616,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);
                     }
@@ -154300,6 +154375,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);
@@ -154308,7 +154384,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).
@@ -154318,6 +154394,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);
@@ -154325,7 +154402,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 = {
@@ -154334,8 +154411,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();
             }
@@ -154372,7 +154450,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)) {
@@ -154380,7 +154458,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);
@@ -154392,7 +154470,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 */) {
@@ -163679,7 +163757,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)
@@ -163738,13 +163816,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/tsserverlibrary.d.ts

@@ -4510,6 +4510,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;