typescript 4.7.0-dev.20220304 → 4.7.0-dev.20220305

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.20220304";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220305";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -39236,7 +39236,8 @@ var ts;
             name: "jsxFragmentFactory",
             type: "string",
             category: ts.Diagnostics.Language_and_Environment,
-            description: ts.Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment
+            description: ts.Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment,
+            defaultValueDescription: "React.Fragment",
         },
         {
             name: "jsxImportSource",
@@ -44325,7 +44326,7 @@ var ts;
             return ts.isDottedName(expr)
                 || (ts.isPropertyAccessExpression(expr) || ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression)
                 || ts.isBinaryExpression(expr) && expr.operatorToken.kind === 27 /* CommaToken */ && isNarrowableReference(expr.right)
-                || ts.isElementAccessExpression(expr) && ts.isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression)
+                || ts.isElementAccessExpression(expr) && (ts.isStringOrNumericLiteralLike(expr.argumentExpression) || ts.isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression)
                 || ts.isAssignmentExpression(expr) && isNarrowableReference(expr.left);
         }
         function containsNarrowableReference(expr) {
@@ -52561,7 +52562,15 @@ var ts;
                             });
                         }
                     }
-                    if (!symbolName) {
+                    if (symbolName === undefined) {
+                        var name = ts.firstDefined(symbol.declarations, ts.getNameOfDeclaration);
+                        if (name && ts.isComputedPropertyName(name) && ts.isEntityName(name.expression)) {
+                            var LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
+                            if (ts.isEntityName(LHS)) {
+                                return ts.factory.createIndexedAccessTypeNode(ts.factory.createParenthesizedType(ts.factory.createTypeQueryNode(LHS)), ts.factory.createTypeQueryNode(name.expression));
+                            }
+                            return LHS;
+                        }
                         symbolName = getNameOfSymbolAsWritten(symbol, context);
                     }
                     context.approximateLength += symbolName.length + 1;
@@ -65301,7 +65310,7 @@ var ts;
                 var requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source) && !isEmptyArrayLiteralType(source) && !isTupleType(source);
                 var unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties, /*matchDiscriminantProperties*/ false);
                 if (unmatchedProperty) {
-                    if (reportErrors) {
+                    if (reportErrors && shouldReportUnmatchedPropertyError(source, target)) {
                         reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
                     }
                     return 0 /* False */;
@@ -65457,6 +65466,19 @@ var ts;
                 }
                 return result;
             }
+            function shouldReportUnmatchedPropertyError(source, target) {
+                var typeCallSignatures = getSignaturesOfStructuredType(source, 0 /* Call */);
+                var typeConstructSignatures = getSignaturesOfStructuredType(source, 1 /* Construct */);
+                var typeProperties = getPropertiesOfObjectType(source);
+                if ((typeCallSignatures.length || typeConstructSignatures.length) && !typeProperties.length) {
+                    if ((getSignaturesOfType(target, 0 /* Call */).length && typeCallSignatures.length) ||
+                        (getSignaturesOfType(target, 1 /* Construct */).length && typeConstructSignatures.length)) {
+                        return true; // target has similar signature kinds to source, still focus on the unmatched property
+                    }
+                    return false;
+                }
+                return true;
+            }
             function reportIncompatibleCallSignatureReturn(siga, sigb) {
                 if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
                     return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); };
@@ -68032,8 +68054,9 @@ var ts;
                     return isMatchingReference(source.expression, target);
                 case 205 /* PropertyAccessExpression */:
                 case 206 /* ElementAccessExpression */:
-                    return ts.isAccessExpression(target) &&
-                        getAccessedPropertyName(source) === getAccessedPropertyName(target) &&
+                    var sourcePropertyName = getAccessedPropertyName(source);
+                    var targetPropertyName = ts.isAccessExpression(target) ? getAccessedPropertyName(target) : undefined;
+                    return sourcePropertyName !== undefined && targetPropertyName !== undefined && targetPropertyName === sourcePropertyName &&
                         isMatchingReference(source.expression, target.expression);
                 case 160 /* QualifiedName */:
                     return ts.isAccessExpression(target) &&
@@ -68045,12 +68068,49 @@ var ts;
             return false;
         }
         function getAccessedPropertyName(access) {
-            var propertyName;
-            return access.kind === 205 /* PropertyAccessExpression */ ? access.name.escapedText :
-                access.kind === 206 /* ElementAccessExpression */ && ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) :
-                    access.kind === 202 /* BindingElement */ && (propertyName = getDestructuringPropertyName(access)) ? ts.escapeLeadingUnderscores(propertyName) :
-                        access.kind === 163 /* Parameter */ ? ("" + access.parent.parameters.indexOf(access)) :
-                            undefined;
+            if (ts.isPropertyAccessExpression(access)) {
+                return access.name.escapedText;
+            }
+            if (ts.isElementAccessExpression(access)) {
+                return tryGetElementAccessExpressionName(access);
+            }
+            if (ts.isBindingElement(access)) {
+                var name = getDestructuringPropertyName(access);
+                return name ? ts.escapeLeadingUnderscores(name) : undefined;
+            }
+            if (ts.isParameter(access)) {
+                return ("" + access.parent.parameters.indexOf(access));
+            }
+            return undefined;
+        }
+        function tryGetNameFromType(type) {
+            return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName :
+                type.flags & 384 /* StringOrNumberLiteral */ ? ts.escapeLeadingUnderscores("" + type.value) : undefined;
+        }
+        function tryGetElementAccessExpressionName(node) {
+            if (ts.isStringOrNumericLiteralLike(node.argumentExpression)) {
+                return ts.escapeLeadingUnderscores(node.argumentExpression.text);
+            }
+            if (ts.isEntityNameExpression(node.argumentExpression)) {
+                var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
+                if (!symbol || !isConstVariable(symbol))
+                    return undefined;
+                var declaration = symbol.valueDeclaration;
+                if (declaration === undefined)
+                    return undefined;
+                var type = tryGetTypeFromEffectiveTypeNode(declaration);
+                if (type) {
+                    var name = tryGetNameFromType(type);
+                    if (name !== undefined) {
+                        return name;
+                    }
+                }
+                if (ts.hasOnlyExpressionInitializer(declaration)) {
+                    var initializer = ts.getEffectiveInitializer(declaration);
+                    return initializer && tryGetNameFromType(getTypeOfExpression(initializer));
+                }
+            }
+            return undefined;
         }
         function containsMatchingReference(source, target) {
             while (ts.isAccessExpression(source)) {
@@ -71556,11 +71616,21 @@ var ts;
             }
             return false;
         }
+        function uniqueStrings(strings) {
+            var unique = new ts.Set(strings);
+            var result = [];
+            unique.forEach(function (str) { return result.push(str); });
+            return result;
+        }
         function discriminateContextualTypeByObjectMembers(node, contextualType) {
-            return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 295 /* PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType);
+            return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 295 /* PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(uniqueStrings(ts.flatMap(contextualType.types, function (memberType) {
+                return ts.map(ts.filter(getPropertiesOfType(memberType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return s.escapedName; });
+            })), function (name) { return [function () { return undefinedType; }, name]; })), isTypeAssignableTo, contextualType);
         }
         function discriminateContextualTypeByJSXAttributes(node, contextualType) {
-            return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 284 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType);
+            return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 284 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(uniqueStrings(ts.flatMap(contextualType.types, function (memberType) {
+                return ts.map(ts.filter(getPropertiesOfType(memberType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return s.escapedName; });
+            })), function (name) { return [function () { return undefinedType; }, name]; })), isTypeAssignableTo, contextualType);
         }
         // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily
         // be "pushed" onto a node using the contextualType property.
@@ -73055,21 +73125,20 @@ var ts;
             // of the property as base classes
             var enclosingClass = forEachEnclosingClass(location, function (enclosingDeclaration) {
                 var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
-                return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing) ? enclosingClass : undefined;
+                return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
             });
             // A protected property is accessible if the property is within the declaring class or classes derived from it
             if (!enclosingClass) {
                 // allow PropertyAccessibility if context is in function with this parameter
-                // static member access is disallow
-                var thisParameter = void 0;
-                if (flags & 32 /* Static */ || !(thisParameter = getThisParameterFromNodeContext(location)) || !thisParameter.type) {
+                // static member access is disallowed
+                enclosingClass = getEnclosingClassFromThisParameter(location);
+                enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
+                if (flags & 32 /* Static */ || !enclosingClass) {
                     if (errorNode) {
                         error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || containingType));
                     }
                     return false;
                 }
-                var thisType = getTypeFromTypeNode(thisParameter.type);
-                enclosingClass = ((thisType.flags & 262144 /* TypeParameter */) ? getConstraintOfTypeParameter(thisType) : thisType).target;
             }
             // No further restrictions for static properties
             if (flags & 32 /* Static */) {
@@ -73087,6 +73156,17 @@ var ts;
             }
             return true;
         }
+        function getEnclosingClassFromThisParameter(node) {
+            var thisParameter = getThisParameterFromNodeContext(node);
+            var thisType = (thisParameter === null || thisParameter === void 0 ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
+            if (thisType && thisType.flags & 262144 /* TypeParameter */) {
+                thisType = getConstraintOfTypeParameter(thisType);
+            }
+            if (thisType && ts.getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
+                return getTargetType(thisType);
+            }
+            return undefined;
+        }
         function getThisParameterFromNodeContext(node) {
             var thisContainer = ts.getThisContainer(node, /* includeArrowFunctions */ false);
             return thisContainer && ts.isFunctionLike(thisContainer) ? ts.getThisParameter(thisContainer) : undefined;
@@ -75195,7 +75275,7 @@ var ts;
                 // then it cannot be instantiated.
                 // In the case of a merged class-module or class-interface declaration,
                 // only the class declaration node will have the Abstract flag set.
-                if (constructSignatures.some(function (signature) { return signature.flags & 4 /* Abstract */; })) {
+                if (someSignature(constructSignatures, function (signature) { return !!(signature.flags & 4 /* Abstract */); })) {
                     error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
                     return resolveErrorCall(node);
                 }
@@ -75226,6 +75306,12 @@ var ts;
             invocationError(node.expression, expressionType, 1 /* Construct */);
             return resolveErrorCall(node);
         }
+        function someSignature(signatures, f) {
+            if (ts.isArray(signatures)) {
+                return ts.some(signatures, function (signature) { return someSignature(signature, f); });
+            }
+            return signatures.compositeKind === 1048576 /* Union */ ? ts.some(signatures.compositeSignatures, f) : f(signatures);
+        }
         function typeHasProtectedAccessibleBase(target, type) {
             var baseTypes = getBaseTypes(type);
             if (!ts.length(baseTypes)) {
@@ -77068,7 +77154,7 @@ var ts;
                 case 40 /* MinusToken */:
                 case 54 /* TildeToken */:
                     checkNonNullType(operandType, node.operand);
-                    if (maybeTypeOfKind(operandType, 12288 /* ESSymbolLike */)) {
+                    if (maybeTypeOfKindConsideringBaseConstraint(operandType, 12288 /* ESSymbolLike */)) {
                         error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator));
                     }
                     if (node.operator === 39 /* PlusToken */) {
@@ -77116,6 +77202,13 @@ var ts;
             // If it's not a bigint type, implicit coercion will result in a number
             return numberType;
         }
+        function maybeTypeOfKindConsideringBaseConstraint(type, kind) {
+            if (maybeTypeOfKind(type, kind)) {
+                return true;
+            }
+            var baseConstraint = getBaseConstraintOrType(type);
+            return !!baseConstraint && maybeTypeOfKind(baseConstraint, kind);
+        }
         // Return true if type might be of the given kind. A union or intersection type might be of a given
         // kind if at least one constituent type is of the given kind.
         function maybeTypeOfKind(type, kind) {
@@ -77825,8 +77918,8 @@ var ts;
             }
             // Return true if there was no error, false if there was an error.
             function checkForDisallowedESSymbolOperand(operator) {
-                var offendingSymbolOperand = maybeTypeOfKind(leftType, 12288 /* ESSymbolLike */) ? left :
-                    maybeTypeOfKind(rightType, 12288 /* ESSymbolLike */) ? right :
+                var offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left :
+                    maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right :
                         undefined;
                 if (offendingSymbolOperand) {
                     error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator));
@@ -78030,7 +78123,7 @@ var ts;
             for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
                 var span = _a[_i];
                 var type = checkExpression(span.expression);
-                if (maybeTypeOfKind(type, 12288 /* ESSymbolLike */)) {
+                if (maybeTypeOfKindConsideringBaseConstraint(type, 12288 /* ESSymbolLike */)) {
                     error(span.expression, ts.Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String);
                 }
                 texts.push(span.literal.text);
@@ -83057,7 +83150,7 @@ var ts;
                 }
                 if (!ts.isStatic(member) && isPropertyWithoutInitializer(member)) {
                     var propName = member.name;
-                    if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName)) {
+                    if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName) || ts.isComputedPropertyName(propName)) {
                         var type = getTypeOfSymbol(getSymbolOfNode(member));
                         if (!(type.flags & 3 /* AnyOrUnknown */ || getFalsyFlags(type) & 32768 /* Undefined */)) {
                             if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
@@ -83092,7 +83185,9 @@ var ts;
             return false;
         }
         function isPropertyInitializedInConstructor(propName, propType, constructor) {
-            var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName);
+            var reference = ts.isComputedPropertyName(propName)
+                ? ts.factory.createElementAccessExpression(ts.factory.createThis(), propName.expression)
+                : ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName);
             ts.setParent(reference.expression, reference);
             ts.setParent(reference, constructor);
             reference.flowNode = constructor.returnFlowNode;
@@ -92649,10 +92744,7 @@ var ts;
                 var substitute = typeof constantValue === "string" ? factory.createStringLiteral(constantValue) : factory.createNumericLiteral(constantValue);
                 if (!compilerOptions.removeComments) {
                     var originalNode = ts.getOriginalNode(node, ts.isAccessExpression);
-                    var propertyName = ts.isPropertyAccessExpression(originalNode)
-                        ? ts.declarationNameToString(originalNode.name)
-                        : safeMultiLineComment(ts.getTextOfNode(originalNode.argumentExpression));
-                    ts.addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, " " + propertyName + " ");
+                    ts.addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, " " + safeMultiLineComment(ts.getTextOfNode(originalNode)) + " ");
                 }
                 return substitute;
             }
@@ -150853,8 +150945,10 @@ var ts;
             var checker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
             var symbolName = getSymbolName(sourceFile, checker, symbolToken, compilerOptions);
-            // "default" is a keyword and not a legal identifier for the import, so we don't expect it here
-            ts.Debug.assert(symbolName !== "default" /* Default */, "'default' isn't a legal identifier and couldn't occur here");
+            // "default" is a keyword and not a legal identifier for the import, but appears as an identifier.
+            if (symbolName === "default" /* Default */) {
+                return undefined;
+            }
             var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
             var useRequire = shouldUseRequire(sourceFile, program);
             var exportInfo = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);