typescript 4.5.0-dev.20210923 → 4.5.0-dev.20210924

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.20210923";
+    ts.version = ts.versionMajorMinor + ".0-dev.20210924";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4928,6 +4928,7 @@ var ts;
         CheckFlags[CheckFlags["HasNeverType"] = 131072] = "HasNeverType";
         CheckFlags[CheckFlags["Mapped"] = 262144] = "Mapped";
         CheckFlags[CheckFlags["StripOptional"] = 524288] = "StripOptional";
+        CheckFlags[CheckFlags["Unresolved"] = 1048576] = "Unresolved";
         CheckFlags[CheckFlags["Synthetic"] = 6] = "Synthetic";
         CheckFlags[CheckFlags["Discriminant"] = 192] = "Discriminant";
         CheckFlags[CheckFlags["Partial"] = 48] = "Partial";
@@ -46629,10 +46630,13 @@ var ts;
         var undefinedProperties = new ts.Map();
         var unknownSymbol = createSymbol(4 /* Property */, "unknown");
         var resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
+        var unresolvedSymbols = new ts.Map();
+        var errorTypes = new ts.Map();
         var anyType = createIntrinsicType(1 /* Any */, "any");
         var autoType = createIntrinsicType(1 /* Any */, "any");
         var wildcardType = createIntrinsicType(1 /* Any */, "any");
         var errorType = createIntrinsicType(1 /* Any */, "error");
+        var unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
         var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 131072 /* ContainsWideningType */);
         var intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
         var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
@@ -50071,7 +50075,9 @@ var ts;
             var typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0), writer);
             if (typeNode === undefined)
                 return ts.Debug.fail("should always get typenode");
-            var options = { removeComments: true };
+            // The unresolved type gets a synthesized comment on `any` to hint to users that it's not a plain `any`.
+            // Otherwise, we always strip comments out.
+            var options = { removeComments: type !== unresolvedType };
             var printer = ts.createPrinter(options);
             var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
             printer.writeNode(4 /* Unspecified */, typeNode, /*sourceFile*/ sourceFile, writer);
@@ -50216,6 +50222,12 @@ var ts;
                     type = getReducedType(type);
                 }
                 if (type.flags & 1 /* Any */) {
+                    if (type.aliasSymbol) {
+                        return ts.factory.createTypeReferenceNode(symbolToEntityNameNode(type.aliasSymbol), mapToTypeNodes(type.aliasTypeArguments, context));
+                    }
+                    if (type === unresolvedType) {
+                        return ts.addSyntheticLeadingComment(ts.factory.createKeywordTypeNode(130 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "unresolved");
+                    }
                     context.approximateLength += 3;
                     return ts.factory.createKeywordTypeNode(type === intrinsicMarkerType ? 138 /* IntrinsicKeyword */ : 130 /* AnyKeyword */);
                 }
@@ -51304,6 +51316,10 @@ var ts;
                 }
                 return specifier;
             }
+            function symbolToEntityNameNode(symbol) {
+                var identifier = ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(symbol.escapedName));
+                return symbol.parent ? ts.factory.createQualifiedName(symbolToEntityNameNode(symbol.parent), identifier) : identifier;
+            }
             function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) {
                 var chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */)); // If we're using aliases outside the current scope, dont bother with the module
                 var isTypeOf = meaning === 111551 /* Value */;
@@ -51590,7 +51606,7 @@ var ts;
              * so a `unique symbol` is returned when appropriate for the input symbol, rather than `typeof sym`
              */
             function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
-                if (type !== errorType && enclosingDeclaration) {
+                if (!isErrorType(type) && enclosingDeclaration) {
                     var declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
                     if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation) && !ts.isGetAccessorDeclaration(declWithExistingAnnotation)) {
                         // try to reuse the existing annotation
@@ -51613,7 +51629,7 @@ var ts;
                 return result;
             }
             function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
-                if (type !== errorType && context.enclosingDeclaration) {
+                if (!isErrorType(type) && context.enclosingDeclaration) {
                     var annotation = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
                     if (!!ts.findAncestor(annotation, function (n) { return n === context.enclosingDeclaration; }) && annotation) {
                         var annotated = getTypeFromTypeNode(annotation);
@@ -51720,7 +51736,7 @@ var ts;
                             /*initializer*/ undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(130 /* AnyKeyword */));
                         }
                     }
-                    if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(getTypeReferenceName(node), 788968 /* Type */, /*ignoreErrors*/ true))) {
+                    if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(node, 788968 /* Type */, /*ignoreErrors*/ true))) {
                         return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
                     }
                     if (ts.isLiteralImportTypeNode(node)) {
@@ -53348,6 +53364,11 @@ var ts;
         function isTypeAny(type) {
             return type && (type.flags & 1 /* Any */) !== 0;
         }
+        function isErrorType(type) {
+            // The only 'any' types that have alias symbols are those manufactured by getTypeFromTypeAliasReference for
+            // a reference to an unresolved symbol. We want those to behave like the errorType.
+            return type === errorType || !!(type.flags & 1 /* Any */ && type.aliasSymbol);
+        }
         // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
         // assigned by contextual typing.
         function getTypeForBindingElementParent(node) {
@@ -53865,7 +53886,7 @@ var ts;
                 if (!declaredType) {
                     return type;
                 }
-                else if (declaredType !== errorType && type !== errorType && !isTypeIdenticalTo(declaredType, type)) {
+                else if (!isErrorType(declaredType) && !isErrorType(type) && !isTypeIdenticalTo(declaredType, type)) {
                     errorNextVariableOrPropertyDeclarationMustHaveSameType(/*firstDeclaration*/ undefined, declaredType, declaration, type);
                 }
             }
@@ -54759,7 +54780,7 @@ var ts;
                     for (var _b = 0, implementsTypeNodes_1 = implementsTypeNodes; _b < implementsTypeNodes_1.length; _b++) {
                         var node = implementsTypeNodes_1[_b];
                         var implementsType = getTypeFromTypeNode(node);
-                        if (implementsType !== errorType) {
+                        if (!isErrorType(implementsType)) {
                             if (resolvedImplementsTypes === ts.emptyArray) {
                                 resolvedImplementsTypes = [implementsType];
                             }
@@ -54839,7 +54860,7 @@ var ts;
                 }
                 baseType = getReturnTypeOfSignature(constructors[0]);
             }
-            if (baseType === errorType) {
+            if (isErrorType(baseType)) {
                 return type.resolvedBaseTypes = ts.emptyArray;
             }
             var reducedBaseType = getReducedType(baseType);
@@ -54895,7 +54916,7 @@ var ts;
                         for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) {
                             var node = _c[_b];
                             var baseType = getReducedType(getTypeFromTypeNode(node));
-                            if (baseType !== errorType) {
+                            if (!isErrorType(baseType)) {
                                 if (isValidBaseType(baseType)) {
                                     if (type !== baseType && !hasBaseType(baseType, type)) {
                                         if (type.resolvedBaseTypes === ts.emptyArray) {
@@ -56737,7 +56758,7 @@ var ts;
             for (var _i = 0, _c = containingType.types; _i < _c.length; _i++) {
                 var current = _c[_i];
                 var type = getApparentType(current);
-                if (!(type === errorType || type.flags & 131072 /* Never */)) {
+                if (!(isErrorType(type) || type.flags & 131072 /* Never */)) {
                     var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
                     var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
                     if (prop) {
@@ -57687,7 +57708,7 @@ var ts;
                     }
                     else {
                         var type = getTypeFromTypeNode(constraintDeclaration);
-                        if (type.flags & 1 /* Any */ && type !== errorType) { // Allow errorType to propegate to keep downstream errors suppressed
+                        if (type.flags & 1 /* Any */ && !isErrorType(type)) { // Allow errorType to propegate to keep downstream errors suppressed
                             // use keyofConstraintType as the base constraint for mapped type key constraints (unknown isn;t assignable to that, but `any` was),
                             // use unknown otherwise
                             type = constraintDeclaration.parent.parent.kind === 194 /* MappedType */ ? keyofConstraintType : unknownType;
@@ -57859,6 +57880,18 @@ var ts;
          * declared type. Instantiations are cached using the type identities of the type arguments as the key.
          */
         function getTypeFromTypeAliasReference(node, symbol) {
+            if (ts.getCheckFlags(symbol) & 1048576 /* Unresolved */) {
+                var typeArguments = typeArgumentsFromTypeReferenceNode(node);
+                var id = getAliasId(symbol, typeArguments);
+                var errorType_1 = errorTypes.get(id);
+                if (!errorType_1) {
+                    errorType_1 = createIntrinsicType(1 /* Any */, "error");
+                    errorType_1.aliasSymbol = symbol;
+                    errorType_1.aliasTypeArguments = typeArguments;
+                    errorTypes.set(id, errorType_1);
+                }
+                return errorType_1;
+            }
             var type = getDeclaredTypeOfSymbol(symbol);
             var typeParameters = getSymbolLinks(symbol).typeParameters;
             if (typeParameters) {
@@ -57900,11 +57933,37 @@ var ts;
             }
             return undefined;
         }
-        function resolveTypeReferenceName(typeReferenceName, meaning, ignoreErrors) {
-            if (!typeReferenceName) {
+        function getSymbolPath(symbol) {
+            return symbol.parent ? getSymbolPath(symbol.parent) + "." + symbol.escapedName : symbol.escapedName;
+        }
+        function getUnresolvedSymbolForEntityName(name) {
+            var identifier = name.kind === 160 /* QualifiedName */ ? name.right :
+                name.kind === 205 /* PropertyAccessExpression */ ? name.name :
+                    name;
+            var text = identifier.escapedText;
+            if (text) {
+                var parentSymbol = name.kind === 160 /* QualifiedName */ ? getUnresolvedSymbolForEntityName(name.left) :
+                    name.kind === 205 /* PropertyAccessExpression */ ? getUnresolvedSymbolForEntityName(name.expression) :
+                        undefined;
+                var path = parentSymbol ? getSymbolPath(parentSymbol) + "." + text : text;
+                var result = unresolvedSymbols.get(path);
+                if (!result) {
+                    unresolvedSymbols.set(path, result = createSymbol(524288 /* TypeAlias */, text, 1048576 /* Unresolved */));
+                    result.parent = parentSymbol;
+                    result.declaredType = unresolvedType;
+                }
+                return result;
+            }
+            return unknownSymbol;
+        }
+        function resolveTypeReferenceName(typeReference, meaning, ignoreErrors) {
+            var name = getTypeReferenceName(typeReference);
+            if (!name) {
                 return unknownSymbol;
             }
-            return resolveEntityName(typeReferenceName, meaning, ignoreErrors) || unknownSymbol;
+            var symbol = resolveEntityName(name, meaning, ignoreErrors);
+            return symbol && symbol !== unknownSymbol ? symbol :
+                ignoreErrors ? unknownSymbol : getUnresolvedSymbolForEntityName(name);
         }
         function getTypeReferenceType(node, symbol) {
             if (symbol === unknownSymbol) {
@@ -57929,7 +57988,7 @@ var ts;
                 }
                 else {
                     // Resolve the type reference as a Type for the purpose of reporting errors.
-                    resolveTypeReferenceName(getTypeReferenceName(node), 788968 /* Type */);
+                    resolveTypeReferenceName(node, 788968 /* Type */);
                     return getTypeOfSymbol(symbol);
                 }
             }
@@ -58073,18 +58132,18 @@ var ts;
                 if (isJSDocTypeReference(node)) {
                     type = getIntendedTypeFromJSDocTypeReference(node);
                     if (!type) {
-                        symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning, /*ignoreErrors*/ true);
+                        symbol = resolveTypeReferenceName(node, meaning, /*ignoreErrors*/ true);
                         if (symbol === unknownSymbol) {
-                            symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning | 111551 /* Value */);
+                            symbol = resolveTypeReferenceName(node, meaning | 111551 /* Value */);
                         }
                         else {
-                            resolveTypeReferenceName(getTypeReferenceName(node), meaning); // Resolve again to mark errors, if any
+                            resolveTypeReferenceName(node, meaning); // Resolve again to mark errors, if any
                         }
                         type = getTypeReferenceType(node, symbol);
                     }
                 }
                 if (!type) {
-                    symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning);
+                    symbol = resolveTypeReferenceName(node, meaning);
                     type = getTypeReferenceType(node, symbol);
                 }
                 // Cache both the resolved symbol and the resolved type. The resolved symbol is needed when we check the
@@ -58345,7 +58404,7 @@ var ts;
         function mayResolveTypeAlias(node) {
             switch (node.kind) {
                 case 177 /* TypeReference */:
-                    return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node.typeName, 788968 /* Type */).flags & 524288 /* TypeAlias */);
+                    return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node, 788968 /* Type */).flags & 524288 /* TypeAlias */);
                 case 180 /* TypeQuery */:
                     return true;
                 case 192 /* TypeOperator */:
@@ -60874,7 +60933,7 @@ var ts;
                 var mappedTypeVariable = instantiateType(typeVariable, mapper);
                 if (typeVariable !== mappedTypeVariable) {
                     return mapTypeWithAlias(getReducedType(mappedTypeVariable), function (t) {
-                        if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && t !== errorType) {
+                        if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
                             if (!type.declaration.nameType) {
                                 if (isArrayType(t)) {
                                     return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
@@ -60916,7 +60975,7 @@ var ts;
         }
         function instantiateMappedArrayType(arrayType, mappedType, mapper) {
             var elementType = instantiateMappedTypeTemplate(mappedType, numberType, /*isOptional*/ true, mapper);
-            return elementType === errorType ? errorType :
+            return isErrorType(elementType) ? errorType :
                 createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
         }
         function instantiateMappedTupleType(tupleType, mappedType, mapper) {
@@ -62498,7 +62557,7 @@ var ts;
                             var targetTypes = target.types;
                             var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
                             var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
-                            if (intrinsicAttributes !== errorType && intrinsicClassAttributes !== errorType &&
+                            if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) &&
                                 (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
                                 // do not report top error
                                 return result;
@@ -69475,8 +69534,7 @@ var ts;
                 if (result) {
                     return result;
                 }
-                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name)) {
-                    // This is less a contextual type and more an implied shape - in some cases, this may be undesirable
+                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name)) { // This is less a contextual type and more an implied shape - in some cases, this may be undesirable
                     return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false);
                 }
             }
@@ -70057,7 +70115,7 @@ var ts;
             var propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
             propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType);
             var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
-            if (intrinsicAttribs !== errorType) {
+            if (!isErrorType(intrinsicAttribs)) {
                 propsType = intersectTypes(intrinsicAttribs, propsType);
             }
             return propsType;
@@ -70150,7 +70208,7 @@ var ts;
                 // Normal case -- add in IntrinsicClassElements<T> and IntrinsicElements
                 var apparentAttributesType = attributesType;
                 var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context);
-                if (intrinsicClassAttribs !== errorType) {
+                if (!isErrorType(intrinsicClassAttribs)) {
                     var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
                     var hostClassType = getReturnTypeOfSignature(sig);
                     apparentAttributesType = intersectTypes(typeParams
@@ -70158,7 +70216,7 @@ var ts;
                         : intrinsicClassAttribs, apparentAttributesType);
                 }
                 var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
-                if (intrinsicAttribs !== errorType) {
+                if (!isErrorType(intrinsicAttribs)) {
                     apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
                 }
                 return apparentAttributesType;
@@ -70626,7 +70684,7 @@ var ts;
                             checkSpreadPropOverrides(mergedType, allPropertiesTable, memberDecl);
                         }
                         offset = propertiesArray.length;
-                        if (spread === errorType) {
+                        if (isErrorType(spread)) {
                             continue;
                         }
                         spread = getSpreadType(spread, mergedType, node.symbol, objectFlags, inConstContext);
@@ -70683,7 +70741,7 @@ var ts;
                     }
                 }
             }
-            if (spread === errorType) {
+            if (isErrorType(spread)) {
                 return errorType;
             }
             if (spread !== emptyObjectType) {
@@ -70950,7 +71008,7 @@ var ts;
             var links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
                 var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node);
-                if (intrinsicElementsType !== errorType) {
+                if (!isErrorType(intrinsicElementsType)) {
                     // Property case
                     if (!ts.isIdentifier(node.tagName))
                         return ts.Debug.fail();
@@ -71113,7 +71171,7 @@ var ts;
             //      var CustomTag: "h1" = "h1";
             //      <CustomTag> Hello World </CustomTag>
             var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location);
-            if (intrinsicElementsType !== errorType) {
+            if (!isErrorType(intrinsicElementsType)) {
                 var stringLiteralTypeName = type.value;
                 var intrinsicProp = getPropertyOfType(intrinsicElementsType, ts.escapeLeadingUnderscores(stringLiteralTypeName));
                 if (intrinsicProp) {
@@ -71181,7 +71239,7 @@ var ts;
         }
         function getJsxElementClassTypeAt(location) {
             var type = getJsxType(JsxNames.ElementClass, location);
-            if (type === errorType)
+            if (isErrorType(type))
                 return undefined;
             return type;
         }
@@ -71487,7 +71545,7 @@ var ts;
         }
         function checkNonNullNonVoidType(type, node) {
             var nonNullType = checkNonNullType(type, node);
-            if (nonNullType !== errorType && nonNullType.flags & 16384 /* Void */) {
+            if (nonNullType.flags & 16384 /* Void */) {
                 error(node, ts.Diagnostics.Object_is_possibly_undefined);
             }
             return nonNullType;
@@ -71604,7 +71662,7 @@ var ts;
                 }
                 if (isAnyLike) {
                     if (lexicallyScopedSymbol) {
-                        return apparentType;
+                        return isErrorType(apparentType) ? errorType : apparentType;
                     }
                     if (!ts.getContainingClass(right)) {
                         grammarErrorOnNode(right, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
@@ -71628,7 +71686,8 @@ var ts;
                     if (ts.isIdentifier(left) && parentSymbol) {
                         markAliasReferenced(parentSymbol, node);
                     }
-                    return apparentType;
+                    return isErrorType(apparentType) ? errorType : apparentType;
+                    ;
                 }
                 prop = getPropertyOfType(apparentType, right.escapedText);
             }
@@ -72087,7 +72146,7 @@ var ts;
         }
         function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
             // Short-circuiting for improved performance.
-            if (type === errorType || isTypeAny(type)) {
+            if (isTypeAny(type)) {
                 return true;
             }
             var prop = getPropertyOfType(type, propertyName);
@@ -72105,7 +72164,7 @@ var ts;
          */
         function isPropertyAccessible(node, isSuper, isWrite, containingType, property) {
             // Short-circuiting for improved performance.
-            if (containingType === errorType || isTypeAny(containingType)) {
+            if (isTypeAny(containingType)) {
                 return true;
             }
             // A #private property access in an optional chain is an error dealt with by the parser.
@@ -72176,7 +72235,7 @@ var ts;
             var objectType = ts.getAssignmentTargetKind(node) !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType;
             var indexExpression = node.argumentExpression;
             var indexType = checkExpression(indexExpression);
-            if (objectType === errorType || objectType === silentNeverType) {
+            if (isErrorType(objectType) || objectType === silentNeverType) {
                 return objectType;
             }
             if (isConstEnumObjectType(objectType) && !ts.isStringLiteralLike(indexExpression)) {
@@ -72421,7 +72480,7 @@ var ts;
             // 'let f: (x: string) => number = wrap(s => s.length)', we infer from the declared type of 'f' to the
             // return type of 'wrap'.
             if (node.kind !== 164 /* Decorator */) {
-                var contextualType = getContextualType(node, 8 /* SkipBindingPatterns */);
+                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 /* SkipBindingPatterns */ : 0 /* None */);
                 if (contextualType) {
                     // We clone the inference context to avoid disturbing a resolution in progress for an
                     // outer call expression. Effectively we just want a snapshot of whatever has been
@@ -73370,7 +73429,7 @@ var ts;
                     }
                     return anySignature;
                 }
-                if (superType !== errorType) {
+                if (!isErrorType(superType)) {
                     // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated
                     // with the type arguments specified in the extends clause.
                     var baseTypeNode = ts.getEffectiveBaseTypeNode(ts.getContainingClass(node));
@@ -73398,7 +73457,7 @@ var ts;
                 return silentNeverSignature;
             }
             var apparentType = getApparentType(funcType);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 // Another error has already been reported
                 return resolveErrorCall(node);
             }
@@ -73414,7 +73473,7 @@ var ts;
             if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
                 // The unknownType indicates that an error already occurred (and was reported).  No
                 // need to report another error in this case.
-                if (funcType !== errorType && node.typeArguments) {
+                if (!isErrorType(funcType) && node.typeArguments) {
                     error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
                 }
                 return resolveUntypedCall(node);
@@ -73491,7 +73550,7 @@ var ts;
             // signatures for overload resolution. The result type of the function call becomes
             // the result type of the operation.
             expressionType = getApparentType(expressionType);
-            if (expressionType === errorType) {
+            if (isErrorType(expressionType)) {
                 // Another error has already been reported
                 return resolveErrorCall(node);
             }
@@ -73706,7 +73765,7 @@ var ts;
         function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) {
             var tagType = checkExpression(node.tag);
             var apparentType = getApparentType(tagType);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 // Another error has already been reported
                 return resolveErrorCall(node);
             }
@@ -73752,7 +73811,7 @@ var ts;
         function resolveDecorator(node, candidatesOutArray, checkMode) {
             var funcType = checkExpression(node.expression);
             var apparentType = getApparentType(funcType);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 return resolveErrorCall(node);
             }
             var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
@@ -73807,7 +73866,7 @@ var ts;
             }
             var exprTypes = checkExpression(node.tagName);
             var apparentType = getApparentType(exprTypes);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 return resolveErrorCall(node);
             }
             var signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node);
@@ -74130,7 +74189,7 @@ var ts;
         }
         function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) {
             var _a;
-            if (allowSyntheticDefaultImports && type && type !== errorType) {
+            if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
                 var synthType = type;
                 if (!synthType.syntheticType) {
                     var file = (_a = originalSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
@@ -74236,7 +74295,7 @@ var ts;
             checkSourceElement(type);
             exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType));
             var targetType = getTypeFromTypeNode(type);
-            if (produceDiagnostics && targetType !== errorType) {
+            if (produceDiagnostics && !isErrorType(targetType)) {
                 var widenedType = getWidenedType(exprType);
                 if (!isTypeComparableTo(targetType, widenedType)) {
                     checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
@@ -74269,7 +74328,7 @@ var ts;
                     return getGlobalImportMetaExpressionType();
                 case 103 /* NewKeyword */:
                     var type = checkNewTargetMetaProperty(node);
-                    return type === errorType ? errorType : createNewTargetExpressionType(type);
+                    return isErrorType(type) ? errorType : createNewTargetExpressionType(type);
                 default:
                     ts.Debug.assertNever(node.keywordToken);
             }
@@ -75262,7 +75321,7 @@ var ts;
             }
             var operandType = checkExpression(node.expression);
             var awaitedType = checkAwaitedType(operandType, /*withAlias*/ true, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-            if (awaitedType === operandType && awaitedType !== errorType && !(operandType.flags & 3 /* AnyOrUnknown */)) {
+            if (awaitedType === operandType && !isErrorType(awaitedType) && !(operandType.flags & 3 /* AnyOrUnknown */)) {
                 addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression));
             }
             return awaitedType;
@@ -75903,7 +75962,7 @@ var ts;
                     else if (isTypeAny(leftType) || isTypeAny(rightType)) {
                         // Otherwise, the result is of type Any.
                         // NOTE: unknown type here denotes error type. Old compiler treated this case as any type so do we.
-                        resultType = leftType === errorType || rightType === errorType ? errorType : anyType;
+                        resultType = isErrorType(leftType) || isErrorType(rightType) ? errorType : anyType;
                     }
                     // Symbols are not allowed at all in arithmetic expressions
                     if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
@@ -77381,7 +77440,7 @@ var ts;
         }
         function getTypeParametersForTypeReference(node) {
             var type = getTypeFromTypeReference(node);
-            if (type !== errorType) {
+            if (!isErrorType(type)) {
                 var symbol = getNodeLinks(node).resolvedSymbol;
                 if (symbol) {
                     return symbol.flags & 524288 /* TypeAlias */ && getSymbolLinks(symbol).typeParameters ||
@@ -77397,7 +77456,7 @@ var ts;
             }
             ts.forEach(node.typeArguments, checkSourceElement);
             var type = getTypeFromTypeReference(node);
-            if (type !== errorType) {
+            if (!isErrorType(type)) {
                 if (node.typeArguments && produceDiagnostics) {
                     var typeParameters = getTypeParametersForTypeReference(node);
                     if (typeParameters) {
@@ -78223,7 +78282,7 @@ var ts;
             //
             var returnType = getTypeFromTypeNode(returnTypeNode);
             if (languageVersion >= 2 /* ES2015 */) {
-                if (returnType === errorType) {
+                if (isErrorType(returnType)) {
                     return;
                 }
                 var globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true);
@@ -78237,7 +78296,7 @@ var ts;
             else {
                 // Always mark the type node as referenced if it points to a value
                 markTypeNodeAsReferenced(returnTypeNode);
-                if (returnType === errorType) {
+                if (isErrorType(returnType)) {
                     return;
                 }
                 var promiseConstructorName = ts.getEntityNameFromTypeNode(returnTypeNode);
@@ -78247,7 +78306,7 @@ var ts;
                 }
                 var promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551 /* Value */, /*ignoreErrors*/ true);
                 var promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType;
-                if (promiseConstructorType === errorType) {
+                if (isErrorType(promiseConstructorType)) {
                     if (promiseConstructorName.kind === 79 /* Identifier */ && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(/*reportErrors*/ false)) {
                         error(returnTypeNode, ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
                     }
@@ -79299,7 +79358,7 @@ var ts;
                 // Node is a secondary declaration, check that type is identical to primary declaration and check that
                 // initializer is consistent with type associated with the node
                 var declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node));
-                if (type !== errorType && declarationType !== errorType &&
+                if (!isErrorType(type) && !isErrorType(declarationType) &&
                     !isTypeIdenticalTo(type, declarationType) &&
                     !(symbol.flags & 67108864 /* Assignment */)) {
                     errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType);
@@ -80797,7 +80856,7 @@ var ts;
                     checkTypeReferenceNode(typeRefNode);
                     if (produceDiagnostics) {
                         var t = getReducedType(getTypeFromTypeNode(typeRefNode));
-                        if (t !== errorType) {
+                        if (!isErrorType(t)) {
                             if (isValidBaseType(t)) {
                                 var genericDiag = t.symbol && t.symbol.flags & 32 /* Class */ ?
                                     ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass :
@@ -82837,7 +82896,8 @@ var ts;
             }
             else if (isTypeReferenceIdentifier(name)) {
                 var meaning = name.parent.kind === 177 /* TypeReference */ ? 788968 /* Type */ : 1920 /* Namespace */;
-                return resolveEntityName(name, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ true);
+                var symbol = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ true);
+                return symbol && symbol !== unknownSymbol ? symbol : getUnresolvedSymbolForEntityName(name);
             }
             if (name.parent.kind === 176 /* TypePredicate */) {
                 return resolveEntityName(name, /*meaning*/ 1 /* FunctionScopedVariable */);
@@ -83064,7 +83124,7 @@ var ts;
                 var symbol = getSymbolAtLocation(node);
                 if (symbol) {
                     var declaredType = getDeclaredTypeOfSymbol(symbol);
-                    return declaredType !== errorType ? declaredType : getTypeOfSymbol(symbol);
+                    return !isErrorType(declaredType) ? declaredType : getTypeOfSymbol(symbol);
                 }
             }
             if (ts.isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
@@ -83562,7 +83622,7 @@ var ts;
                 return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown;
             }
             var type = getDeclaredTypeOfSymbol(typeSymbol);
-            if (type === errorType) {
+            if (isErrorType(type)) {
                 return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown;
             }
             else if (type.flags & 3 /* AnyOrUnknown */) {
@@ -127363,7 +127423,7 @@ var ts;
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
             return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
         }
-        function createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences) {
+        function createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, isTypeOnlyImport, useSemicolons, options, preferences) {
             var _a;
             var insertText;
             var replacementSpan = ts.getReplacementSpanForContextToken(contextToken);
@@ -127417,7 +127477,7 @@ var ts;
             if (originIsResolvedExport(origin)) {
                 sourceDisplay = [ts.textPart(origin.moduleSpecifier)];
                 if (importCompletionNode) {
-                    (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, origin, useSemicolons, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan);
+                    (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, isTypeOnlyImport, origin, useSemicolons, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan);
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
@@ -127490,7 +127550,7 @@ var ts;
                 moduleSpecifier: originIsResolvedExport(origin) ? origin.moduleSpecifier : undefined,
             };
         }
-        function getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, origin, useSemicolons, options, preferences) {
+        function getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, isTypeOnly, origin, useSemicolons, options, preferences) {
             var sourceFile = importCompletionNode.getSourceFile();
             var replacementSpan = ts.createTextSpanFromNode(importCompletionNode, sourceFile);
             var quotedModuleSpecifier = ts.quote(sourceFile, preferences, origin.moduleSpecifier);
@@ -127499,12 +127559,13 @@ var ts;
                     0 /* Named */;
             var tabStop = preferences.includeCompletionsWithSnippetText ? "$1" : "";
             var importKind = ts.codefix.getImportKind(sourceFile, exportKind, options, /*forceImportKeyword*/ true);
+            var typeOnlyPrefix = isTypeOnly ? " " + ts.tokenToString(151 /* TypeKeyword */) + " " : " ";
             var suffix = useSemicolons ? ";" : "";
             switch (importKind) {
-                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import " + escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
-                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import " + escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
-                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import * as " + escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
-                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import { " + escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
+                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
+                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
+                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + "* as " + escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
+                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + "{ " + escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
             }
         }
         function quotePropertyName(sourceFile, preferences, name) {
@@ -127533,6 +127594,7 @@ var ts;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
             var useSemicolons = ts.probablyUsesSemicolons(sourceFile);
+            var isTypeOnlyImport = !!importCompletionNode && ts.isTypeOnlyImportOrExportDeclaration(location.parent);
             // Tracks unique names.
             // Value is set to false for global variables or completions from external module exports, because we can have multiple of those;
             // true otherwise. Based on the order we add things we will always see locals first, then globals, then module exports.
@@ -127548,7 +127610,7 @@ var ts;
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
                 var sortTextId = (_a = symbolToSortTextIdMap === null || symbolToSortTextIdMap === void 0 ? void 0 : symbolToSortTextIdMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : 11 /* LocationPriority */;
                 var sortText = (isDeprecated(symbol, typeChecker) ? 8 /* DeprecatedOffset */ + sortTextId : sortTextId).toString();
-                var entry = createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences);
+                var entry = createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, isTypeOnlyImport, useSemicolons, compilerOptions, preferences);
                 if (!entry) {
                     continue;
                 }
@@ -128449,6 +128511,7 @@ var ts;
             }
             function isTypeOnlyCompletion() {
                 return insideJsDocTagTypeExpression
+                    || !!importCompletionNode && ts.isTypeOnlyImportOrExportDeclaration(location.parent)
                     || !isContextTokenValueLocation(contextToken) &&
                         (ts.isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker)
                             || ts.isPartOfTypeNode(location)