diff --git a/completionAtDottedNamespace.ts b/completionAtDottedNamespace.ts new file mode 100644 index 00000000000..cbf16435a91 --- /dev/null +++ b/completionAtDottedNamespace.ts @@ -0,0 +1,5 @@ +/// + +////namespace wwer./**/w + +verify.completions({ marker: "", exact: [], isNewIdentifierLocation: true }); diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 7216af4e817..f0e17261810 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -753,7 +753,7 @@ namespace ts { function isNarrowableReference(expr: Expression): boolean { return expr.kind === SyntaxKind.Identifier || expr.kind === SyntaxKind.ThisKeyword || expr.kind === SyntaxKind.SuperKeyword || - isPropertyAccessExpression(expr) && isNarrowableReference(expr.expression) || + (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) || isElementAccessExpression(expr) && expr.argumentExpression && (isStringLiteral(expr.argumentExpression) || isNumericLiteral(expr.argumentExpression)) && isNarrowableReference(expr.expression); diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts index 5d792545257..0db924913f4 100644 --- a/src/compiler/builder.ts +++ b/src/compiler/builder.ts @@ -99,7 +99,8 @@ namespace ts { if (useOldState) { // Verify the sanity of old state if (!oldState!.currentChangedFilePath) { - Debug.assert(!oldState!.affectedFiles && (!oldState!.currentAffectedFilesSignatures || !oldState!.currentAffectedFilesSignatures!.size), "Cannot reuse if only few affected files of currentChangedFile were iterated"); + const affectedSignatures = oldState!.currentAffectedFilesSignatures; + Debug.assert(!oldState!.affectedFiles && (!affectedSignatures || !affectedSignatures.size), "Cannot reuse if only few affected files of currentChangedFile were iterated"); } if (canCopySemanticDiagnostics) { Debug.assert(!forEachKey(oldState!.changedFilesSet, path => oldState!.semanticDiagnosticsPerFile!.has(path)), "Semantic diagnostics shouldnt be available for changed files"); diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 86822e24878..b1f73584c49 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -444,10 +444,10 @@ namespace ts { const circularConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); const resolvingDefaultType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); - const markerSuperType = createType(TypeFlags.TypeParameter); - const markerSubType = createType(TypeFlags.TypeParameter); + const markerSuperType = createTypeParameter(); + const markerSubType = createTypeParameter(); markerSubType.constraint = markerSuperType; - const markerOtherType = createType(TypeFlags.TypeParameter); + const markerOtherType = createTypeParameter(); const noTypePredicate = createIdentifierTypePredicate("<>", 0, anyType); @@ -663,7 +663,6 @@ namespace ts { const subtypeRelation = createMap(); const assignableRelation = createMap(); - const definitelyAssignableRelation = createMap(); const comparableRelation = createMap(); const identityRelation = createMap(); const enumRelation = createMap(); @@ -2408,11 +2407,18 @@ namespace ts { // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable). function resolveESModuleSymbol(moduleSymbol: Symbol | undefined, referencingLocation: Node, dontResolveAlias: boolean): Symbol | undefined { const symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias); + if (!dontResolveAlias && symbol) { if (!(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable)) && !getDeclarationOfKind(symbol, SyntaxKind.SourceFile)) { - error(referencingLocation, Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol!)); + const compilerOptionName = moduleKind >= ModuleKind.ES2015 + ? "allowSyntheticDefaultImports" + : "esModuleInterop"; + + error(referencingLocation, Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName); + return symbol; } + if (compilerOptions.esModuleInterop) { const referenceParent = referencingLocation.parent; if ( @@ -2745,6 +2751,12 @@ namespace ts { return getUnionType(arrayFrom(typeofEQFacts.keys(), getLiteralType)); } + function createTypeParameter(symbol?: Symbol) { + const type = createType(TypeFlags.TypeParameter); + if (symbol) type.symbol = symbol; + return type; + } + // A reserved member name starts with two underscores, but the third character cannot be an underscore // or the @ symbol. A third underscore indicates an escaped form of an identifer that started // with at least two underscores. The @ character indicates that the name is denoted by a well known ES @@ -5419,6 +5431,10 @@ namespace ts { // Handle variable, parameter or property if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) { + // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty` + if (symbol.flags & SymbolFlags.ValueModule) { + return getTypeOfFuncClassEnumModule(symbol); + } return errorType; } let type: Type | undefined; @@ -5474,6 +5490,10 @@ namespace ts { } if (!popTypeResolution()) { + // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty` + if (symbol.flags & SymbolFlags.ValueModule) { + return getTypeOfFuncClassEnumModule(symbol); + } type = reportCircularityError(symbol); } return type; @@ -6085,9 +6105,8 @@ namespace ts { (type).instantiations.set(getTypeListId(type.typeParameters), type); (type).target = type; (type).typeArguments = type.typeParameters; - type.thisType = createType(TypeFlags.TypeParameter); + type.thisType = createTypeParameter(symbol); type.thisType.isThisType = true; - type.thisType.symbol = symbol; type.thisType.constraint = type; } } @@ -6228,20 +6247,12 @@ namespace ts { function getDeclaredTypeOfTypeParameter(symbol: Symbol): TypeParameter { const links = getSymbolLinks(symbol); - if (!links.declaredType) { - const type = createType(TypeFlags.TypeParameter); - type.symbol = symbol; - links.declaredType = type; - } - return links.declaredType; + return links.declaredType || (links.declaredType = createTypeParameter(symbol)); } function getDeclaredTypeOfAlias(symbol: Symbol): Type { const links = getSymbolLinks(symbol); - if (!links.declaredType) { - links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol)); - } - return links.declaredType; + return links.declaredType || (links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol))); } function getDeclaredTypeOfSymbol(symbol: Symbol): Type { @@ -7413,7 +7424,7 @@ namespace ts { if (type.root.isDistributive) { const simplified = getSimplifiedType(type.checkType); const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified; - if (constraint) { + if (constraint && constraint !== type.checkType) { const mapper = makeUnaryTypeMapper(type.root.checkType, constraint); const instantiated = getConditionalTypeInstantiation(type, combineTypeMappers(mapper, type.mapper)); if (!(instantiated.flags & TypeFlags.Never)) { @@ -9049,7 +9060,7 @@ namespace ts { if (arity) { typeParameters = new Array(arity); for (let i = 0; i < arity; i++) { - const typeParameter = typeParameters[i] = createType(TypeFlags.TypeParameter); + const typeParameter = typeParameters[i] = createTypeParameter(); if (i < maxLength) { const property = createSymbol(SymbolFlags.Property | (i >= minLength ? SymbolFlags.Optional : 0), "" + i as __String); property.type = typeParameter; @@ -9070,7 +9081,7 @@ namespace ts { type.instantiations.set(getTypeListId(type.typeParameters), type); type.target = type; type.typeArguments = type.typeParameters; - type.thisType = createType(TypeFlags.TypeParameter); + type.thisType = createTypeParameter(); type.thisType.isThisType = true; type.thisType.constraint = type; type.declaredProperties = properties; @@ -9971,7 +9982,7 @@ namespace ts { if (checkType === wildcardType || extendsType === wildcardType) { return wildcardType; } - const checkTypeInstantiable = maybeTypeOfKind(checkType, TypeFlags.Instantiable); + const checkTypeInstantiable = maybeTypeOfKind(checkType, TypeFlags.Instantiable | TypeFlags.GenericMappedType); let combinedMapper: TypeMapper | undefined; if (root.inferTypeParameters) { const context = createInferenceContext(root.inferTypeParameters, /*signature*/ undefined, InferenceFlags.None); @@ -9986,7 +9997,7 @@ namespace ts { // Instantiate the extends type including inferences for 'infer T' type parameters const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType; // We attempt to resolve the conditional type only when the check and extends types are non-generic - if (!checkTypeInstantiable && !maybeTypeOfKind(inferredExtendsType, TypeFlags.Instantiable)) { + if (!checkTypeInstantiable && !maybeTypeOfKind(inferredExtendsType, TypeFlags.Instantiable | TypeFlags.GenericMappedType)) { if (inferredExtendsType.flags & TypeFlags.AnyOrUnknown) { return instantiateType(root.trueType, mapper); } @@ -9998,14 +10009,15 @@ namespace ts { // types with type parameters mapped to the wildcard type, the most permissive instantiations // possible (the wildcard type is assignable to and from all types). If those are not related, // then no instatiations will be and we can just return the false branch type. - if (!isTypeAssignableTo(getWildcardInstantiation(checkType), getWildcardInstantiation(inferredExtendsType))) { + if (!isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType))) { return instantiateType(root.falseType, mapper); } - // Return trueType for a definitely true extends check. The definitely assignable relation excludes - // type variable constraints from consideration. Without the definitely assignable relation, the type + // Return trueType for a definitely true extends check. We check instantiations of the two + // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter + // that has no constraint. This ensures that, for example, the type // type Foo = T extends { x: string } ? string : number - // would immediately resolve to 'string' instead of being deferred. - if (checkTypeRelatedTo(checkType, inferredExtendsType, definitelyAssignableRelation, /*errorNode*/ undefined)) { + // doesn't immediately resolve to 'string' instead of being deferred. + if (isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) { return instantiateType(root.trueType, combinedMapper || mapper); } } @@ -10611,13 +10623,20 @@ namespace ts { return t => t === source ? target : baseMapper(t); } - function wildcardMapper(type: Type) { + function permissiveMapper(type: Type) { return type.flags & TypeFlags.TypeParameter ? wildcardType : type; } + function getRestrictiveTypeParameter(tp: TypeParameter) { + return !tp.constraint ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol)); + } + + function restrictiveMapper(type: Type) { + return type.flags & TypeFlags.TypeParameter ? getRestrictiveTypeParameter(type) : type; + } + function cloneTypeParameter(typeParameter: TypeParameter): TypeParameter { - const result = createType(TypeFlags.TypeParameter); - result.symbol = typeParameter.symbol; + const result = createTypeParameter(typeParameter.symbol); result.target = typeParameter; return result; } @@ -10969,9 +10988,14 @@ namespace ts { return type; } - function getWildcardInstantiation(type: Type) { + function getPermissiveInstantiation(type: Type) { return type.flags & (TypeFlags.Primitive | TypeFlags.AnyOrUnknown | TypeFlags.Never) ? type : - type.wildcardInstantiation || (type.wildcardInstantiation = instantiateType(type, wildcardMapper)); + type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper)); + } + + function getRestrictiveInstantiation(type: Type) { + return type.flags & (TypeFlags.Primitive | TypeFlags.AnyOrUnknown | TypeFlags.Never) ? type : + type.restrictiveInstantiation || (type.restrictiveInstantiation = instantiateType(type, restrictiveMapper)); } function instantiateIndexInfo(info: IndexInfo | undefined, mapper: TypeMapper): IndexInfo | undefined { @@ -11644,7 +11668,7 @@ namespace ts { if (s & TypeFlags.Null && (!strictNullChecks || t & TypeFlags.Null)) return true; if (s & TypeFlags.Object && t & TypeFlags.NonPrimitive) return true; if (s & TypeFlags.UniqueESSymbol || t & TypeFlags.UniqueESSymbol) return false; - if (relation === assignableRelation || relation === definitelyAssignableRelation || relation === comparableRelation) { + if (relation === assignableRelation || relation === comparableRelation) { if (s & TypeFlags.Any) return true; // Type number or any numeric literal type is assignable to any numeric enum type or any // numeric enum literal type. This rule exists for backwards compatibility reasons because @@ -11836,7 +11860,7 @@ namespace ts { target = (target).regularType; } if (source.flags & TypeFlags.Substitution) { - source = relation === definitelyAssignableRelation ? (source).typeVariable : (source).substitute; + source = (source).substitute; } if (target.flags & TypeFlags.Substitution) { target = (target).typeVariable; @@ -12022,7 +12046,7 @@ namespace ts { } if (isExcessPropertyCheckTarget(target)) { const isComparingJsxAttributes = !!(getObjectFlags(source) & ObjectFlags.JsxAttributes); - if ((relation === assignableRelation || relation === definitelyAssignableRelation || relation === comparableRelation) && + if ((relation === assignableRelation || relation === comparableRelation) && (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) { return false; } @@ -12425,24 +12449,22 @@ namespace ts { } // A type S is assignable to keyof T if S is assignable to keyof C, where C is the // simplified form of T or, if T doesn't simplify, the constraint of T. - if (relation !== definitelyAssignableRelation) { - const simplified = getSimplifiedType((target).type); - const constraint = simplified !== (target).type ? simplified : getConstraintOfType((target).type); - if (constraint) { - // We require Ternary.True here such that circular constraints don't cause - // false positives. For example, given 'T extends { [K in keyof T]: string }', - // 'keyof T' has itself as its constraint and produces a Ternary.Maybe when - // related to other types. - if (isRelatedTo(source, getIndexType(constraint, (target as IndexType).stringsOnly), reportErrors) === Ternary.True) { - return Ternary.True; - } + const simplified = getSimplifiedType((target).type); + const constraint = simplified !== (target).type ? simplified : getConstraintOfType((target).type); + if (constraint) { + // We require Ternary.True here such that circular constraints don't cause + // false positives. For example, given 'T extends { [K in keyof T]: string }', + // 'keyof T' has itself as its constraint and produces a Ternary.Maybe when + // related to other types. + if (isRelatedTo(source, getIndexType(constraint, (target as IndexType).stringsOnly), reportErrors) === Ternary.True) { + return Ternary.True; } } } else if (target.flags & TypeFlags.IndexedAccess) { // A type S is related to a type T[K], where T and K aren't both type variables, if S is related to C, // where C is the base constraint of T[K] - if (relation !== identityRelation && relation !== definitelyAssignableRelation && + if (relation !== identityRelation && !(isGenericObjectType((target).objectType) && isGenericIndexType((target).indexType))) { const constraint = getBaseConstraintOfType(target); if (constraint && constraint !== target) { @@ -12485,26 +12507,24 @@ namespace ts { return result; } } - if (relation !== definitelyAssignableRelation) { - const constraint = getConstraintOfType(source); - if (!constraint || (source.flags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any)) { - // A type variable with no constraint is not related to the non-primitive object type. - if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive))) { - errorInfo = saveErrorInfo; - return result; - } - } - // 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, /*reportErrors*/ false, /*headMessage*/ undefined, isIntersectionConstituent)) { - errorInfo = 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, reportErrors, /*headMessage*/ undefined, isIntersectionConstituent)) { + const constraint = getConstraintOfType(source); + if (!constraint || (source.flags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any)) { + // A type variable with no constraint is not related to the non-primitive object type. + if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive))) { errorInfo = saveErrorInfo; return result; } } + // 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, /*reportErrors*/ false, /*headMessage*/ undefined, isIntersectionConstituent)) { + errorInfo = 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, reportErrors, /*headMessage*/ undefined, isIntersectionConstituent)) { + errorInfo = saveErrorInfo; + return result; + } } else if (source.flags & TypeFlags.Index) { if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) { @@ -12528,7 +12548,7 @@ namespace ts { } } } - else if (relation !== definitelyAssignableRelation) { + else { const distributiveConstraint = getConstraintOfDistributiveConditionalType(source); if (distributiveConstraint) { if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) { @@ -12559,9 +12579,6 @@ namespace ts { } return Ternary.False; } - if (relation === definitelyAssignableRelation && isGenericMappedType(source)) { - return Ternary.False; - } const sourceIsPrimitive = !!(source.flags & TypeFlags.Primitive); if (relation !== identityRelation) { source = getApparentType(source); @@ -14764,6 +14781,9 @@ namespace ts { return symbol !== unknownSymbol ? (isConstraintPosition(node) ? "@" : "") + getSymbolId(symbol) : undefined; case SyntaxKind.ThisKeyword: return "0"; + case SyntaxKind.NonNullExpression: + case SyntaxKind.ParenthesizedExpression: + return getFlowCacheKey((node).expression); case SyntaxKind.PropertyAccessExpression: case SyntaxKind.ElementAccessExpression: const propName = getAccessedPropertyName(node); @@ -14776,6 +14796,11 @@ namespace ts { } function isMatchingReference(source: Node, target: Node): boolean { + switch (target.kind) { + case SyntaxKind.ParenthesizedExpression: + case SyntaxKind.NonNullExpression: + return isMatchingReference(source, (target as NonNullExpression | ParenthesizedExpression).expression); + } switch (source.kind) { case SyntaxKind.Identifier: return target.kind === SyntaxKind.Identifier && getResolvedSymbol(source) === getResolvedSymbol(target) || @@ -14785,6 +14810,9 @@ namespace ts { return target.kind === SyntaxKind.ThisKeyword; case SyntaxKind.SuperKeyword: return target.kind === SyntaxKind.SuperKeyword; + case SyntaxKind.NonNullExpression: + case SyntaxKind.ParenthesizedExpression: + return isMatchingReference((source as NonNullExpression | ParenthesizedExpression).expression, target); case SyntaxKind.PropertyAccessExpression: case SyntaxKind.ElementAccessExpression: return isAccessExpression(target) && @@ -16625,7 +16653,7 @@ namespace ts { function checkThisBeforeSuper(node: Node, container: Node, diagnosticMessage: DiagnosticMessage) { const containingClassDecl = container.parent; - const baseTypeNode = getEffectiveBaseTypeNode(containingClassDecl); + const baseTypeNode = getClassExtendsHeritageElement(containingClassDecl); // If a containing class does not have extends clause or the class extends null // skip checking whether super statement is called before "this" accessing. @@ -16974,7 +17002,7 @@ namespace ts { // at this point the only legal case for parent is ClassLikeDeclaration const classLikeDeclaration = container.parent; - if (!getEffectiveBaseTypeNode(classLikeDeclaration)) { + if (!getClassExtendsHeritageElement(classLikeDeclaration)) { error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class); return errorType; } @@ -23575,7 +23603,7 @@ namespace ts { // Constructors of classes with no extends clause may not contain super calls, whereas // constructors of derived classes must contain at least one super call somewhere in their function body. const containingClassDecl = node.parent; - if (getEffectiveBaseTypeNode(containingClassDecl)) { + if (getClassExtendsHeritageElement(containingClassDecl)) { captureLexicalThis(node.parent, containingClassDecl); const classExtendsNull = classDeclarationExtendsNull(containingClassDecl); const superCall = getSuperCallInConstructor(node); diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 1dbc7ca4710..0496d07405f 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1776,7 +1776,7 @@ "category": "Error", "code": 2496 }, - "Module '{0}' resolves to a non-module entity and cannot be imported using this construct.": { + "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export.": { "category": "Error", "code": 2497 }, @@ -4815,5 +4815,9 @@ "Add names to all parameters without names": { "category": "Message", "code": 95073 + }, + "Enable the 'experimentalDecorators' option in your configuration file": { + "category": "Message", + "code": 95074 } } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 9c09ed79a77..62aba51afec 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2561,6 +2561,7 @@ namespace ts { function emitJsxSelfClosingElement(node: JsxSelfClosingElement) { writePunctuation("<"); emitJsxTagName(node.tagName); + emitTypeArguments(node, node.typeArguments); writeSpace(); emit(node.attributes); writePunctuation("/>"); @@ -2577,6 +2578,7 @@ namespace ts { if (isJsxOpeningElement(node)) { emitJsxTagName(node.tagName); + emitTypeArguments(node, node.typeArguments); if (node.attributes.properties && node.attributes.properties.length > 0) { writeSpace(); } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index f976f77ea98..53e45505014 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -7774,17 +7774,18 @@ namespace ts { const libReferenceDirectives = context.libReferenceDirectives; forEach(toArray(entryOrList), (arg: PragmaPseudoMap["reference"]) => { // TODO: GH#18217 + const { types, lib, path } = arg!.arguments; if (arg!.arguments["no-default-lib"]) { context.hasNoDefaultLib = true; } - else if (arg!.arguments.types) { - typeReferenceDirectives.push({ pos: arg!.arguments.types!.pos, end: arg!.arguments.types!.end, fileName: arg!.arguments.types!.value }); + else if (types) { + typeReferenceDirectives.push({ pos: types.pos, end: types.end, fileName: types.value }); } - else if (arg!.arguments.lib) { - libReferenceDirectives.push({ pos: arg!.arguments.lib!.pos, end: arg!.arguments.lib!.end, fileName: arg!.arguments.lib!.value }); + else if (lib) { + libReferenceDirectives.push({ pos: lib.pos, end: lib.end, fileName: lib.value }); } - else if (arg!.arguments.path) { - referencedFiles.push({ pos: arg!.arguments.path!.pos, end: arg!.arguments.path!.end, fileName: arg!.arguments.path!.value }); + else if (path) { + referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value }); } else { reportDiagnostic(arg!.range.pos, arg!.range.end - arg!.range.pos, Diagnostics.Invalid_reference_directive_syntax); diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 7dd57a07b9f..fbe9a6c5089 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -2234,8 +2234,9 @@ namespace ts { processReferencedFiles(file, isDefaultLib); processTypeReferenceDirectives(file); } - - processLibReferenceDirectives(file); + if (!options.noLib) { + processLibReferenceDirectives(file); + } modulesWithElidedImports.set(file.path, false); processImportedModules(file); @@ -2322,8 +2323,10 @@ namespace ts { processReferencedFiles(file, isDefaultLib); processTypeReferenceDirectives(file); } + if (!options.noLib) { + processLibReferenceDirectives(file); + } - processLibReferenceDirectives(file); // always process imported modules to record module name resolutions processImportedModules(file); diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 700c0c8af25..a22c6df8d06 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1898,6 +1898,7 @@ namespace ts { case SyntaxKind.StringLiteral: return createIdentifier("String"); + case SyntaxKind.PrefixUnaryExpression: case SyntaxKind.NumericLiteral: return createIdentifier("Number"); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 19eb8607711..852437942f1 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -3916,7 +3916,9 @@ namespace ts { aliasTypeArguments?: ReadonlyArray; // Alias type arguments (if any) /* @internal */ aliasTypeArgumentsContainsMarker?: boolean; // Alias type arguments (if any) /* @internal */ - wildcardInstantiation?: Type; // Instantiation with type parameters mapped to wildcard type + permissiveInstantiation?: Type; // Instantiation with type parameters mapped to wildcard type + /* @internal */ + restrictiveInstantiation?: Type; // Instantiation with type parameters mapped to unconstrained form /* @internal */ immediateBaseConstraint?: Type; // Immediate base constraint cache } diff --git a/src/harness/compiler.ts b/src/harness/compiler.ts index 532a2d65578..70bda90ef32 100644 --- a/src/harness/compiler.ts +++ b/src/harness/compiler.ts @@ -183,8 +183,9 @@ namespace compiler { } public getSourceMapRecord(): string | undefined { - if (this.result!.sourceMaps && this.result!.sourceMaps!.length > 0) { - return Harness.SourceMapRecorder.getSourceMapRecord(this.result!.sourceMaps!, this.program!, Array.from(this.js.values()).filter(d => !ts.fileExtensionIs(d.file, ts.Extension.Json)), Array.from(this.dts.values())); + const maps = this.result!.sourceMaps; + if (maps && maps.length > 0) { + return Harness.SourceMapRecorder.getSourceMapRecord(maps, this.program!, Array.from(this.js.values()).filter(d => !ts.fileExtensionIs(d.file, ts.Extension.Json)), Array.from(this.dts.values())); } } diff --git a/src/services/codefixes/fixCannotFindModule.ts b/src/services/codefixes/fixCannotFindModule.ts index 1c7070c74bf..1baaa9714f2 100644 --- a/src/services/codefixes/fixCannotFindModule.ts +++ b/src/services/codefixes/fixCannotFindModule.ts @@ -74,7 +74,7 @@ namespace ts.codefix { const tsconfigObjectLiteral = getTsConfigObjectLiteralExpression(configFile); if (!tsconfigObjectLiteral) return undefined; - const compilerOptionsProperty = findProperty(tsconfigObjectLiteral, "compilerOptions"); + const compilerOptionsProperty = findJsonProperty(tsconfigObjectLiteral, "compilerOptions"); if (!compilerOptionsProperty) { const newCompilerOptions = createObjectLiteral([makeDefaultBaseUrl(), makeDefaultPaths()]); changes.insertNodeAtObjectStart(configFile, tsconfigObjectLiteral, createJsonPropertyAssignment("compilerOptions", newCompilerOptions)); @@ -94,7 +94,7 @@ namespace ts.codefix { return createJsonPropertyAssignment("baseUrl", createStringLiteral(defaultBaseUrl)); } function getOrAddBaseUrl(changes: textChanges.ChangeTracker, tsconfig: TsConfigSourceFile, compilerOptions: ObjectLiteralExpression): string { - const baseUrlProp = findProperty(compilerOptions, "baseUrl"); + const baseUrlProp = findJsonProperty(compilerOptions, "baseUrl"); if (baseUrlProp) { return isStringLiteral(baseUrlProp.initializer) ? baseUrlProp.initializer.text : defaultBaseUrl; } @@ -112,7 +112,7 @@ namespace ts.codefix { return createJsonPropertyAssignment("paths", createObjectLiteral([makeDefaultPathMapping()])); } function getOrAddPathMapping(changes: textChanges.ChangeTracker, tsconfig: TsConfigSourceFile, compilerOptions: ObjectLiteralExpression) { - const paths = findProperty(compilerOptions, "paths"); + const paths = findJsonProperty(compilerOptions, "paths"); if (!paths || !isObjectLiteralExpression(paths.initializer)) { changes.insertNodeAtObjectStart(tsconfig, compilerOptions, makeDefaultPaths()); return defaultTypesDirectoryName; @@ -129,14 +129,6 @@ namespace ts.codefix { return defaultTypesDirectoryName; } - function createJsonPropertyAssignment(name: string, initializer: Expression) { - return createPropertyAssignment(createStringLiteral(name), initializer); - } - - function findProperty(obj: ObjectLiteralExpression, name: string): PropertyAssignment | undefined { - return find(obj.properties, (p): p is PropertyAssignment => isPropertyAssignment(p) && !!p.name && isStringLiteral(p.name) && p.name.text === name); - } - function getInstallCommand(fileName: string, packageName: string): InstallPackageAction { return { type: "install package", file: fileName, packageName }; } diff --git a/src/services/codefixes/fixEnableExperimentalDecorators.ts b/src/services/codefixes/fixEnableExperimentalDecorators.ts new file mode 100644 index 00000000000..8aeefe48a47 --- /dev/null +++ b/src/services/codefixes/fixEnableExperimentalDecorators.ts @@ -0,0 +1,24 @@ +/* @internal */ +namespace ts.codefix { + const fixId = "enableExperimentalDecorators"; + const errorCodes = [ + Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_to_remove_this_warning.code + ]; + registerCodeFix({ + errorCodes, + getCodeActions: (context) => { + const { configFile } = context.program.getCompilerOptions(); + if (configFile === undefined) { + return undefined; + } + + const changes = textChanges.ChangeTracker.with(context, changeTracker => makeChange(changeTracker, configFile)); + return [createCodeFixActionNoFixId(fixId, changes, Diagnostics.Enable_the_experimentalDecorators_option_in_your_configuration_file)]; + }, + fixIds: [fixId], + }); + + function makeChange(changeTracker: textChanges.ChangeTracker, configFile: TsConfigSourceFile) { + setJsonCompilerOptionValue(changeTracker, configFile, "experimentalDecorators", createTrue()); + } +} diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 461771c0b5e..66488d5d697 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -249,4 +249,46 @@ namespace ts.codefix { } return undefined; } + + export function setJsonCompilerOptionValue( + changeTracker: textChanges.ChangeTracker, + configFile: TsConfigSourceFile, + optionName: string, + optionValue: Expression, + ) { + const tsconfigObjectLiteral = getTsConfigObjectLiteralExpression(configFile); + if (!tsconfigObjectLiteral) return undefined; + + const compilerOptionsProperty = findJsonProperty(tsconfigObjectLiteral, "compilerOptions"); + if (compilerOptionsProperty === undefined) { + changeTracker.insertNodeAtObjectStart(configFile, tsconfigObjectLiteral, createJsonPropertyAssignment( + "compilerOptions", + createObjectLiteral([ + createJsonPropertyAssignment(optionName, optionValue), + ]))); + return; + } + + const compilerOptions = compilerOptionsProperty.initializer; + if (!isObjectLiteralExpression(compilerOptions)) { + return; + } + + const optionProperty = findJsonProperty(compilerOptions, optionName); + + if (optionProperty === undefined) { + changeTracker.insertNodeAtObjectStart(configFile, compilerOptions, createJsonPropertyAssignment(optionName, optionValue)); + } + else { + changeTracker.replaceNode(configFile, optionProperty.initializer, optionValue); + } + } + + export function createJsonPropertyAssignment(name: string, initializer: Expression) { + return createPropertyAssignment(createStringLiteral(name), initializer); + } + + export function findJsonProperty(obj: ObjectLiteralExpression, name: string): PropertyAssignment | undefined { + return find(obj.properties, (p): p is PropertyAssignment => isPropertyAssignment(p) && !!p.name && isStringLiteral(p.name) && p.name.text === name); + } } diff --git a/src/services/completions.ts b/src/services/completions.ts index bbcee4dd47e..8203b66549b 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -104,7 +104,7 @@ namespace ts.Completions { getJSCompletionEntries(sourceFile, location!.pos, uniqueNames, compilerOptions.target!, entries); // TODO: GH#18217 } else { - if ((!symbols || symbols.length === 0) && keywordFilters === KeywordCompletionFilters.None) { + if (!isNewIdentifierLocation && (!symbols || symbols.length === 0) && keywordFilters === KeywordCompletionFilters.None) { return undefined; } diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index 15044416f84..21be663055a 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -61,6 +61,7 @@ "codefixes/fixClassDoesntImplementInheritedAbstractMember.ts", "codefixes/fixClassSuperMustPrecedeThisAccess.ts", "codefixes/fixConstructorForDerivedNeedSuperCall.ts", + "codefixes/fixEnableExperimentalDecorators.ts", "codefixes/fixExtendsInterfaceBecomesImplements.ts", "codefixes/fixForgottenThisPropertyAccess.ts", "codefixes/fixUnusedIdentifier.ts", diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.errors.txt b/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.errors.txt new file mode 100644 index 00000000000..5d67f88c847 --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.errors.txt @@ -0,0 +1,22 @@ +tests/cases/compiler/noSuperInJSDocExtends.js(14,9): error TS2335: 'super' can only be referenced in a derived class. + + +==== tests/cases/compiler/noSuperInJSDocExtends.js (1 errors) ==== + class Based { } + /** @extends {Based} */ + class Derived { + constructor() { + this; + this.x = 10; + var that = this; + } + } + + /** @extends {Based} */ + class Derived2 { + constructor() { + super(); + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.symbols b/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.symbols new file mode 100644 index 00000000000..f900a4986eb --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.symbols @@ -0,0 +1,31 @@ +=== tests/cases/compiler/noSuperInJSDocExtends.js === +class Based { } +>Based : Symbol(Based, Decl(noSuperInJSDocExtends.js, 0, 0)) + +/** @extends {Based} */ +class Derived { +>Derived : Symbol(Derived, Decl(noSuperInJSDocExtends.js, 0, 15)) + + constructor() { + this; +>this : Symbol(Derived, Decl(noSuperInJSDocExtends.js, 0, 15)) + + this.x = 10; +>this.x : Symbol(Derived.x, Decl(noSuperInJSDocExtends.js, 4, 13)) +>this : Symbol(Derived, Decl(noSuperInJSDocExtends.js, 0, 15)) +>x : Symbol(Derived.x, Decl(noSuperInJSDocExtends.js, 4, 13)) + + var that = this; +>that : Symbol(that, Decl(noSuperInJSDocExtends.js, 6, 11)) +>this : Symbol(Derived, Decl(noSuperInJSDocExtends.js, 0, 15)) + } +} + +/** @extends {Based} */ +class Derived2 { +>Derived2 : Symbol(Derived2, Decl(noSuperInJSDocExtends.js, 8, 1)) + + constructor() { + super(); + } +} diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.types b/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.types new file mode 100644 index 00000000000..577256400b2 --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccessing9.types @@ -0,0 +1,35 @@ +=== tests/cases/compiler/noSuperInJSDocExtends.js === +class Based { } +>Based : Based + +/** @extends {Based} */ +class Derived { +>Derived : Derived + + constructor() { + this; +>this : this + + this.x = 10; +>this.x = 10 : 10 +>this.x : number +>this : this +>x : number +>10 : 10 + + var that = this; +>that : this +>this : this + } +} + +/** @extends {Based} */ +class Derived2 { +>Derived2 : Derived2 + + constructor() { + super(); +>super() : void +>super : any + } +} diff --git a/tests/baselines/reference/conditionalTypes1.errors.txt b/tests/baselines/reference/conditionalTypes1.errors.txt index 8bf05c043ce..62239eca7b8 100644 --- a/tests/baselines/reference/conditionalTypes1.errors.txt +++ b/tests/baselines/reference/conditionalTypes1.errors.txt @@ -471,4 +471,12 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(288,43): error TS var a = {o: 1, b: 2, c: [{a: 1, c: '213'}]} assign(a, {o: 2, c: {0: {a: 2, c: '213123'}}}) + + // Repros from #23843 + + type Weird1 = ((a: U) => never) extends + ((a: U) => never) ? never : never; + + type Weird2 = ((a: U) => U) extends + ((a: U) => infer T) ? T : never; \ No newline at end of file diff --git a/tests/baselines/reference/conditionalTypes1.js b/tests/baselines/reference/conditionalTypes1.js index 552a80d58a5..7ce19ce17e7 100644 --- a/tests/baselines/reference/conditionalTypes1.js +++ b/tests/baselines/reference/conditionalTypes1.js @@ -351,6 +351,14 @@ declare function assign(o: T, a: RecursivePartial): void; var a = {o: 1, b: 2, c: [{a: 1, c: '213'}]} assign(a, {o: 2, c: {0: {a: 2, c: '213123'}}}) + +// Repros from #23843 + +type Weird1 = ((a: U) => never) extends + ((a: U) => never) ? never : never; + +type Weird2 = ((a: U) => U) extends + ((a: U) => infer T) ? T : never; //// [conditionalTypes1.js] @@ -715,3 +723,5 @@ declare var a: { c: string; }[]; }; +declare type Weird1 = ((a: U) => never) extends ((a: U) => never) ? never : never; +declare type Weird2 = ((a: U) => U) extends ((a: U) => infer T) ? T : never; diff --git a/tests/baselines/reference/conditionalTypes1.symbols b/tests/baselines/reference/conditionalTypes1.symbols index 19f0ae83890..e5c6ae3d6c7 100644 --- a/tests/baselines/reference/conditionalTypes1.symbols +++ b/tests/baselines/reference/conditionalTypes1.symbols @@ -1371,3 +1371,30 @@ assign(a, {o: 2, c: {0: {a: 2, c: '213123'}}}) >a : Symbol(a, Decl(conditionalTypes1.ts, 351, 25)) >c : Symbol(c, Decl(conditionalTypes1.ts, 351, 30)) +// Repros from #23843 + +type Weird1 = ((a: U) => never) extends +>Weird1 : Symbol(Weird1, Decl(conditionalTypes1.ts, 351, 46)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 355, 16)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 355, 35)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 355, 16)) + + ((a: U) => never) ? never : never; +>U : Symbol(U, Decl(conditionalTypes1.ts, 356, 6)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 356, 22)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 356, 6)) + +type Weird2 = ((a: U) => U) extends +>Weird2 : Symbol(Weird2, Decl(conditionalTypes1.ts, 356, 54)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 358, 16)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 358, 35)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 358, 16)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 358, 16)) + + ((a: U) => infer T) ? T : never; +>U : Symbol(U, Decl(conditionalTypes1.ts, 359, 6)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 359, 22)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 359, 6)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 359, 36)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 359, 36)) + diff --git a/tests/baselines/reference/conditionalTypes1.types b/tests/baselines/reference/conditionalTypes1.types index 00d1965eea4..08fdb4b2f29 100644 --- a/tests/baselines/reference/conditionalTypes1.types +++ b/tests/baselines/reference/conditionalTypes1.types @@ -1054,3 +1054,21 @@ assign(a, {o: 2, c: {0: {a: 2, c: '213123'}}}) >c : string >'213123' : "213123" +// Repros from #23843 + +type Weird1 = ((a: U) => never) extends +>Weird1 : never +>a : U + + ((a: U) => never) ? never : never; +>true : true +>a : U + +type Weird2 = ((a: U) => U) extends +>Weird2 : boolean +>a : U + + ((a: U) => infer T) ? T : never; +>true : true +>a : U + diff --git a/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.js b/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.js new file mode 100644 index 00000000000..57b548cdf99 --- /dev/null +++ b/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.js @@ -0,0 +1,28 @@ +//// [decoratorWithNegativeLiteralTypeNoCrash.ts] +class A { + @decorator + public field1: -1 = -1; +} +function decorator(target: any, field: any) {} + +//// [decoratorWithNegativeLiteralTypeNoCrash.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var A = /** @class */ (function () { + function A() { + this.field1 = -1; + } + __decorate([ + decorator, + __metadata("design:type", Number) + ], A.prototype, "field1", void 0); + return A; +}()); +function decorator(target, field) { } diff --git a/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.symbols b/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.symbols new file mode 100644 index 00000000000..e89854249a0 --- /dev/null +++ b/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.symbols @@ -0,0 +1,15 @@ +=== tests/cases/compiler/decoratorWithNegativeLiteralTypeNoCrash.ts === +class A { +>A : Symbol(A, Decl(decoratorWithNegativeLiteralTypeNoCrash.ts, 0, 0)) + + @decorator +>decorator : Symbol(decorator, Decl(decoratorWithNegativeLiteralTypeNoCrash.ts, 3, 1)) + + public field1: -1 = -1; +>field1 : Symbol(A.field1, Decl(decoratorWithNegativeLiteralTypeNoCrash.ts, 0, 9)) +} +function decorator(target: any, field: any) {} +>decorator : Symbol(decorator, Decl(decoratorWithNegativeLiteralTypeNoCrash.ts, 3, 1)) +>target : Symbol(target, Decl(decoratorWithNegativeLiteralTypeNoCrash.ts, 4, 19)) +>field : Symbol(field, Decl(decoratorWithNegativeLiteralTypeNoCrash.ts, 4, 31)) + diff --git a/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.types b/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.types new file mode 100644 index 00000000000..45f4ff03451 --- /dev/null +++ b/tests/baselines/reference/decoratorWithNegativeLiteralTypeNoCrash.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/decoratorWithNegativeLiteralTypeNoCrash.ts === +class A { +>A : A + + @decorator +>decorator : (target: any, field: any) => void + + public field1: -1 = -1; +>field1 : -1 +>-1 : -1 +>1 : 1 +>-1 : -1 +>1 : 1 +} +function decorator(target: any, field: any) {} +>decorator : (target: any, field: any) => void +>target : any +>field : any + diff --git a/tests/baselines/reference/es6ExportEqualsInterop.errors.txt b/tests/baselines/reference/es6ExportEqualsInterop.errors.txt index 4675136d081..5b8e83b3cca 100644 --- a/tests/baselines/reference/es6ExportEqualsInterop.errors.txt +++ b/tests/baselines/reference/es6ExportEqualsInterop.errors.txt @@ -11,24 +11,24 @@ tests/cases/compiler/main.ts(33,8): error TS1192: Module '"function"' has no def tests/cases/compiler/main.ts(34,8): error TS1192: Module '"function-module"' has no default export. tests/cases/compiler/main.ts(35,8): error TS1192: Module '"class"' has no default export. tests/cases/compiler/main.ts(36,8): error TS1192: Module '"class-module"' has no default export. -tests/cases/compiler/main.ts(39,21): error TS2497: Module '"interface"' resolves to a non-module entity and cannot be imported using this construct. -tests/cases/compiler/main.ts(45,21): error TS2497: Module '"function"' resolves to a non-module entity and cannot be imported using this construct. -tests/cases/compiler/main.ts(47,21): error TS2497: Module '"class"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(39,21): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. +tests/cases/compiler/main.ts(45,21): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. +tests/cases/compiler/main.ts(47,21): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(50,1): error TS2693: 'y1' only refers to a type, but is being used as a value here. tests/cases/compiler/main.ts(56,4): error TS2339: Property 'a' does not exist on type '() => any'. tests/cases/compiler/main.ts(58,4): error TS2339: Property 'a' does not exist on type 'typeof Foo'. tests/cases/compiler/main.ts(62,10): error TS2305: Module '"interface"' has no exported member 'a'. -tests/cases/compiler/main.ts(62,25): error TS2497: Module '"interface"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(62,25): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(68,10): error TS2305: Module '"function"' has no exported member 'a'. -tests/cases/compiler/main.ts(68,25): error TS2497: Module '"function"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(68,25): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(70,10): error TS2305: Module '"class"' has no exported member 'a'. -tests/cases/compiler/main.ts(70,25): error TS2497: Module '"class"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(70,25): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(85,10): error TS2305: Module '"interface"' has no exported member 'a'. -tests/cases/compiler/main.ts(85,25): error TS2497: Module '"interface"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(85,25): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(91,10): error TS2305: Module '"function"' has no exported member 'a'. -tests/cases/compiler/main.ts(91,25): error TS2497: Module '"function"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(91,25): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(93,10): error TS2305: Module '"class"' has no exported member 'a'. -tests/cases/compiler/main.ts(93,25): error TS2497: Module '"class"' resolves to a non-module entity and cannot be imported using this construct. +tests/cases/compiler/main.ts(93,25): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. tests/cases/compiler/main.ts(97,15): error TS2498: Module '"interface"' uses 'export =' and cannot be used with 'export *'. tests/cases/compiler/main.ts(98,15): error TS2498: Module '"variable"' uses 'export =' and cannot be used with 'export *'. tests/cases/compiler/main.ts(99,15): error TS2498: Module '"interface-variable"' uses 'export =' and cannot be used with 'export *'. @@ -108,7 +108,7 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses // namespace import import * as y1 from "interface"; ~~~~~~~~~~~ -!!! error TS2497: Module '"interface"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. import * as y2 from "variable"; import * as y3 from "interface-variable"; import * as y4 from "module"; @@ -116,11 +116,11 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses import * as y6 from "variable-module"; import * as y7 from "function"; ~~~~~~~~~~ -!!! error TS2497: Module '"function"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. import * as y8 from "function-module"; import * as y9 from "class"; ~~~~~~~ -!!! error TS2497: Module '"class"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. import * as y0 from "class-module"; y1.a; @@ -145,7 +145,7 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses ~ !!! error TS2305: Module '"interface"' has no exported member 'a'. ~~~~~~~~~~~ -!!! error TS2497: Module '"interface"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. import { a as a2 } from "variable"; import { a as a3 } from "interface-variable"; import { a as a4 } from "module"; @@ -155,13 +155,13 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses ~ !!! error TS2305: Module '"function"' has no exported member 'a'. ~~~~~~~~~~ -!!! error TS2497: Module '"function"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. import { a as a8 } from "function-module"; import { a as a9 } from "class"; ~ !!! error TS2305: Module '"class"' has no exported member 'a'. ~~~~~~~ -!!! error TS2497: Module '"class"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. import { a as a0 } from "class-module"; a1; @@ -180,7 +180,7 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses ~ !!! error TS2305: Module '"interface"' has no exported member 'a'. ~~~~~~~~~~~ -!!! error TS2497: Module '"interface"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. export { a as a2 } from "variable"; export { a as a3 } from "interface-variable"; export { a as a4 } from "module"; @@ -190,13 +190,13 @@ tests/cases/compiler/main.ts(106,15): error TS2498: Module '"class-module"' uses ~ !!! error TS2305: Module '"function"' has no exported member 'a'. ~~~~~~~~~~ -!!! error TS2497: Module '"function"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. export { a as a8 } from "function-module"; export { a as a9 } from "class"; ~ !!! error TS2305: Module '"class"' has no exported member 'a'. ~~~~~~~ -!!! error TS2497: Module '"class"' resolves to a non-module entity and cannot be imported using this construct. +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. export { a as a0 } from "class-module"; // export-star diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.errors.txt b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.errors.txt new file mode 100644 index 00000000000..3d8301d3ca1 --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.errors.txt @@ -0,0 +1,15 @@ +tests/cases/compiler/main.ts(1,20): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + class a { } + export = a; + +==== tests/cases/compiler/main.ts (1 errors) ==== + import * as a from "./a"; + ~~~~~ +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'esModuleInterop' flag and referencing its default export. + a; + + + \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.js b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.js new file mode 100644 index 00000000000..37f127721ce --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.js @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/es6ImportEqualsExportModuleCommonJsError.ts] //// + +//// [a.ts] +class a { } +export = a; + +//// [main.ts] +import * as a from "./a"; +a; + + + + +//// [a.js] +"use strict"; +var a = /** @class */ (function () { + function a() { + } + return a; +}()); +module.exports = a; +//// [main.js] +"use strict"; +exports.__esModule = true; +var a = require("./a"); +a; diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.symbols b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.symbols new file mode 100644 index 00000000000..071f2fb5725 --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +class a { } +>a : Symbol(a, Decl(a.ts, 0, 0)) + +export = a; +>a : Symbol(a, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/main.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(main.ts, 0, 6)) + +a; +>a : Symbol(a, Decl(main.ts, 0, 6)) + + + diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.types b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.types new file mode 100644 index 00000000000..652d7d6241b --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleCommonJsError.types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +class a { } +>a : a + +export = a; +>a : a + +=== tests/cases/compiler/main.ts === +import * as a from "./a"; +>a : typeof a + +a; +>a : typeof a + + + diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.errors.txt b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.errors.txt new file mode 100644 index 00000000000..94c05e068f5 --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.errors.txt @@ -0,0 +1,18 @@ +tests/cases/compiler/a.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead. +tests/cases/compiler/main.ts(1,20): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'allowSyntheticDefaultImports' flag and referencing its default export. + + +==== tests/cases/compiler/a.ts (1 errors) ==== + class a { } + export = a; + ~~~~~~~~~~~ +!!! error TS1203: Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead. + +==== tests/cases/compiler/main.ts (1 errors) ==== + import * as a from "./a"; + ~~~~~ +!!! error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'allowSyntheticDefaultImports' flag and referencing its default export. + a; + + + \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.js b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.js new file mode 100644 index 00000000000..603f158946e --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.js @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/es6ImportEqualsExportModuleEs2015Error.ts] //// + +//// [a.ts] +class a { } +export = a; + +//// [main.ts] +import * as a from "./a"; +a; + + + + +//// [a.js] +var a = /** @class */ (function () { + function a() { + } + return a; +}()); +//// [main.js] +import * as a from "./a"; +a; diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.symbols b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.symbols new file mode 100644 index 00000000000..071f2fb5725 --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +class a { } +>a : Symbol(a, Decl(a.ts, 0, 0)) + +export = a; +>a : Symbol(a, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/main.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(main.ts, 0, 6)) + +a; +>a : Symbol(a, Decl(main.ts, 0, 6)) + + + diff --git a/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.types b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.types new file mode 100644 index 00000000000..652d7d6241b --- /dev/null +++ b/tests/baselines/reference/es6ImportEqualsExportModuleEs2015Error.types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +class a { } +>a : a + +export = a; +>a : a + +=== tests/cases/compiler/main.ts === +import * as a from "./a"; +>a : typeof a + +a; +>a : typeof a + + + diff --git a/tests/baselines/reference/libReferenceNoLib.js b/tests/baselines/reference/libReferenceNoLib.js new file mode 100644 index 00000000000..21d1cbbe177 --- /dev/null +++ b/tests/baselines/reference/libReferenceNoLib.js @@ -0,0 +1,51 @@ +//// [tests/cases/conformance/declarationEmit/libReferenceNoLib.ts] //// + +//// [fakelib.ts] +// Test that passing noLib disables resolution. + +interface Object { } +interface Array { } +interface String { } +interface Boolean { } +interface Number { } +interface Function { } +interface RegExp { } +interface IArguments { } + + +//// [file1.ts] +/// +export declare interface HTMLElement { field: string; } +export const elem: HTMLElement = { field: 'a' }; + + +//// [fakelib.js] +// Test that passing noLib disables resolution. +//// [file1.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.elem = { field: 'a' }; + + +//// [fakelib.d.ts] +interface Object { +} +interface Array { +} +interface String { +} +interface Boolean { +} +interface Number { +} +interface Function { +} +interface RegExp { +} +interface IArguments { +} +//// [file1.d.ts] +export declare interface HTMLElement { + field: string; +} +export declare const elem: HTMLElement; diff --git a/tests/baselines/reference/libReferenceNoLib.symbols b/tests/baselines/reference/libReferenceNoLib.symbols new file mode 100644 index 00000000000..5f180fd1eed --- /dev/null +++ b/tests/baselines/reference/libReferenceNoLib.symbols @@ -0,0 +1,40 @@ +=== tests/cases/conformance/declarationEmit/fakelib.ts === +// Test that passing noLib disables resolution. + +interface Object { } +>Object : Symbol(Object, Decl(fakelib.ts, 0, 0)) + +interface Array { } +>Array : Symbol(Array, Decl(fakelib.ts, 2, 20)) +>T : Symbol(T, Decl(fakelib.ts, 3, 16)) + +interface String { } +>String : Symbol(String, Decl(fakelib.ts, 3, 22)) + +interface Boolean { } +>Boolean : Symbol(Boolean, Decl(fakelib.ts, 4, 20)) + +interface Number { } +>Number : Symbol(Number, Decl(fakelib.ts, 5, 21)) + +interface Function { } +>Function : Symbol(Function, Decl(fakelib.ts, 6, 20)) + +interface RegExp { } +>RegExp : Symbol(RegExp, Decl(fakelib.ts, 7, 22)) + +interface IArguments { } +>IArguments : Symbol(IArguments, Decl(fakelib.ts, 8, 20)) + + +=== tests/cases/conformance/declarationEmit/file1.ts === +/// +export declare interface HTMLElement { field: string; } +>HTMLElement : Symbol(HTMLElement, Decl(file1.ts, 0, 0)) +>field : Symbol(HTMLElement.field, Decl(file1.ts, 1, 38)) + +export const elem: HTMLElement = { field: 'a' }; +>elem : Symbol(elem, Decl(file1.ts, 2, 12)) +>HTMLElement : Symbol(HTMLElement, Decl(file1.ts, 0, 0)) +>field : Symbol(field, Decl(file1.ts, 2, 34)) + diff --git a/tests/baselines/reference/libReferenceNoLib.types b/tests/baselines/reference/libReferenceNoLib.types new file mode 100644 index 00000000000..0b2733c2265 --- /dev/null +++ b/tests/baselines/reference/libReferenceNoLib.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/declarationEmit/fakelib.ts === +// Test that passing noLib disables resolution. +No type information for this code. +No type information for this code.interface Object { } +No type information for this code.interface Array { } +No type information for this code.interface String { } +No type information for this code.interface Boolean { } +No type information for this code.interface Number { } +No type information for this code.interface Function { } +No type information for this code.interface RegExp { } +No type information for this code.interface IArguments { } +No type information for this code. +No type information for this code. +No type information for this code.=== tests/cases/conformance/declarationEmit/file1.ts === +/// +export declare interface HTMLElement { field: string; } +>field : string + +export const elem: HTMLElement = { field: 'a' }; +>elem : HTMLElement +>{ field: 'a' } : { field: string; } +>field : string +>'a' : "a" + diff --git a/tests/baselines/reference/libReferenceNoLibBundle.js b/tests/baselines/reference/libReferenceNoLibBundle.js new file mode 100644 index 00000000000..a881f11a8a1 --- /dev/null +++ b/tests/baselines/reference/libReferenceNoLibBundle.js @@ -0,0 +1,53 @@ +//// [tests/cases/conformance/declarationEmit/libReferenceNoLibBundle.ts] //// + +//// [fakelib.ts] +// Test that passing noLib disables resolution. + +interface Object { } +interface Array { } +interface String { } +interface Boolean { } +interface Number { } +interface Function { } +interface RegExp { } +interface IArguments { } + + +//// [file1.ts] +/// +export declare interface HTMLElement { field: string; } +export const elem: HTMLElement = { field: 'a' }; + + +//// [bundle.js] +// Test that passing noLib disables resolution. +define("file1", ["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.elem = { field: 'a' }; +}); + + +//// [bundle.d.ts] +interface Object { +} +interface Array { +} +interface String { +} +interface Boolean { +} +interface Number { +} +interface Function { +} +interface RegExp { +} +interface IArguments { +} +declare module "file1" { + export interface HTMLElement { + field: string; + } + export const elem: HTMLElement; +} diff --git a/tests/baselines/reference/libReferenceNoLibBundle.symbols b/tests/baselines/reference/libReferenceNoLibBundle.symbols new file mode 100644 index 00000000000..5f180fd1eed --- /dev/null +++ b/tests/baselines/reference/libReferenceNoLibBundle.symbols @@ -0,0 +1,40 @@ +=== tests/cases/conformance/declarationEmit/fakelib.ts === +// Test that passing noLib disables resolution. + +interface Object { } +>Object : Symbol(Object, Decl(fakelib.ts, 0, 0)) + +interface Array { } +>Array : Symbol(Array, Decl(fakelib.ts, 2, 20)) +>T : Symbol(T, Decl(fakelib.ts, 3, 16)) + +interface String { } +>String : Symbol(String, Decl(fakelib.ts, 3, 22)) + +interface Boolean { } +>Boolean : Symbol(Boolean, Decl(fakelib.ts, 4, 20)) + +interface Number { } +>Number : Symbol(Number, Decl(fakelib.ts, 5, 21)) + +interface Function { } +>Function : Symbol(Function, Decl(fakelib.ts, 6, 20)) + +interface RegExp { } +>RegExp : Symbol(RegExp, Decl(fakelib.ts, 7, 22)) + +interface IArguments { } +>IArguments : Symbol(IArguments, Decl(fakelib.ts, 8, 20)) + + +=== tests/cases/conformance/declarationEmit/file1.ts === +/// +export declare interface HTMLElement { field: string; } +>HTMLElement : Symbol(HTMLElement, Decl(file1.ts, 0, 0)) +>field : Symbol(HTMLElement.field, Decl(file1.ts, 1, 38)) + +export const elem: HTMLElement = { field: 'a' }; +>elem : Symbol(elem, Decl(file1.ts, 2, 12)) +>HTMLElement : Symbol(HTMLElement, Decl(file1.ts, 0, 0)) +>field : Symbol(field, Decl(file1.ts, 2, 34)) + diff --git a/tests/baselines/reference/libReferenceNoLibBundle.types b/tests/baselines/reference/libReferenceNoLibBundle.types new file mode 100644 index 00000000000..0b2733c2265 --- /dev/null +++ b/tests/baselines/reference/libReferenceNoLibBundle.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/declarationEmit/fakelib.ts === +// Test that passing noLib disables resolution. +No type information for this code. +No type information for this code.interface Object { } +No type information for this code.interface Array { } +No type information for this code.interface String { } +No type information for this code.interface Boolean { } +No type information for this code.interface Number { } +No type information for this code.interface Function { } +No type information for this code.interface RegExp { } +No type information for this code.interface IArguments { } +No type information for this code. +No type information for this code. +No type information for this code.=== tests/cases/conformance/declarationEmit/file1.ts === +/// +export declare interface HTMLElement { field: string; } +>field : string + +export const elem: HTMLElement = { field: 'a' }; +>elem : HTMLElement +>{ field: 'a' } : { field: string; } +>field : string +>'a' : "a" + diff --git a/tests/baselines/reference/nonNullReferenceMatching.js b/tests/baselines/reference/nonNullReferenceMatching.js new file mode 100644 index 00000000000..abb0d5a96db --- /dev/null +++ b/tests/baselines/reference/nonNullReferenceMatching.js @@ -0,0 +1,54 @@ +//// [nonNullReferenceMatching.ts] +type ElementRef = (element: HTMLElement | null) => void; + +type ThumbProps = { + elementRef?: ElementRef; +} + +type ComponentProps = { + thumbYProps?: ThumbProps; + thumbXProps: ThumbProps; +} + +class Component { + props!: ComponentProps; + public thumbYElementRef = (ref: HTMLElement | null) => { + typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref); + + typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref); + + typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); + + typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); + + typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); + }; +} + +//// [nonNullReferenceMatching.js] +"use strict"; +var Component = /** @class */ (function () { + function Component() { + var _this = this; + this.thumbYElementRef = function (ref) { + typeof _this.props.thumbYProps.elementRef === 'function' && _this.props.thumbYProps.elementRef(ref); + typeof (_this.props.thumbYProps.elementRef) === 'function' && _this.props.thumbYProps.elementRef(ref); + typeof ((_this.props).thumbYProps.elementRef) === 'function' && _this.props.thumbYProps.elementRef(ref); + typeof _this.props.thumbXProps.elementRef === 'function' && _this.props.thumbXProps.elementRef(ref); + typeof _this.props.thumbXProps.elementRef === 'function' && (_this.props).thumbXProps.elementRef(ref); + typeof _this.props.thumbXProps.elementRef === 'function' && (_this.props.thumbXProps).elementRef(ref); + typeof _this.props.thumbXProps.elementRef === 'function' && ((_this.props).thumbXProps).elementRef(ref); + typeof (_this.props.thumbXProps).elementRef === 'function' && ((_this.props).thumbXProps).elementRef(ref); + typeof _this.props.thumbXProps.elementRef === 'function' && ((_this.props).thumbXProps).elementRef(ref); + }; + } + return Component; +}()); diff --git a/tests/baselines/reference/nonNullReferenceMatching.symbols b/tests/baselines/reference/nonNullReferenceMatching.symbols new file mode 100644 index 00000000000..ee9c608cea4 --- /dev/null +++ b/tests/baselines/reference/nonNullReferenceMatching.symbols @@ -0,0 +1,193 @@ +=== tests/cases/compiler/nonNullReferenceMatching.ts === +type ElementRef = (element: HTMLElement | null) => void; +>ElementRef : Symbol(ElementRef, Decl(nonNullReferenceMatching.ts, 0, 0)) +>element : Symbol(element, Decl(nonNullReferenceMatching.ts, 0, 19)) +>HTMLElement : Symbol(HTMLElement, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) + +type ThumbProps = { +>ThumbProps : Symbol(ThumbProps, Decl(nonNullReferenceMatching.ts, 0, 56)) + + elementRef?: ElementRef; +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ElementRef : Symbol(ElementRef, Decl(nonNullReferenceMatching.ts, 0, 0)) +} + +type ComponentProps = { +>ComponentProps : Symbol(ComponentProps, Decl(nonNullReferenceMatching.ts, 4, 1)) + + thumbYProps?: ThumbProps; +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>ThumbProps : Symbol(ThumbProps, Decl(nonNullReferenceMatching.ts, 0, 56)) + + thumbXProps: ThumbProps; +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>ThumbProps : Symbol(ThumbProps, Decl(nonNullReferenceMatching.ts, 0, 56)) +} + +class Component { +>Component : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) + + props!: ComponentProps; +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>ComponentProps : Symbol(ComponentProps, Decl(nonNullReferenceMatching.ts, 4, 1)) + + public thumbYElementRef = (ref: HTMLElement | null) => { +>thumbYElementRef : Symbol(Component.thumbYElementRef, Decl(nonNullReferenceMatching.ts, 12, 27)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) +>HTMLElement : Symbol(HTMLElement, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) + + typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref); +>this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref); +>this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref); +>(this.props).thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props).thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref); +>this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref); +>this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props).thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props).thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref); +>this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props.thumbXProps).elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); +>this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>((this.props)!.thumbXProps)!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); +>(this.props.thumbXProps).elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>((this.props)!.thumbXProps)!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); +>this.props!.thumbXProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>this.props!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>((this.props)!.thumbXProps)!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1)) +>props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17)) +>thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29)) +>elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19)) +>ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31)) + + }; +} diff --git a/tests/baselines/reference/nonNullReferenceMatching.types b/tests/baselines/reference/nonNullReferenceMatching.types new file mode 100644 index 00000000000..03ef70177c0 --- /dev/null +++ b/tests/baselines/reference/nonNullReferenceMatching.types @@ -0,0 +1,262 @@ +=== tests/cases/compiler/nonNullReferenceMatching.ts === +type ElementRef = (element: HTMLElement | null) => void; +>ElementRef : ElementRef +>element : HTMLElement | null +>null : null + +type ThumbProps = { +>ThumbProps : ThumbProps + + elementRef?: ElementRef; +>elementRef : ElementRef | undefined +} + +type ComponentProps = { +>ComponentProps : ComponentProps + + thumbYProps?: ThumbProps; +>thumbYProps : ThumbProps | undefined + + thumbXProps: ThumbProps; +>thumbXProps : ThumbProps +} + +class Component { +>Component : Component + + props!: ComponentProps; +>props : ComponentProps + + public thumbYElementRef = (ref: HTMLElement | null) => { +>thumbYElementRef : (ref: HTMLElement | null) => void +>(ref: HTMLElement | null) => { typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref); typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref); typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref); typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref); typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref); typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref); typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); } : (ref: HTMLElement | null) => void +>ref : HTMLElement | null +>null : null + + typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref); +>typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref) : false | void +>typeof this.props.thumbYProps!.elementRef === 'function' : boolean +>typeof this.props.thumbYProps!.elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>this.props.thumbYProps!.elementRef : ElementRef | undefined +>this.props.thumbYProps! : ThumbProps +>this.props.thumbYProps : ThumbProps | undefined +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbYProps : ThumbProps | undefined +>elementRef : ElementRef | undefined +>'function' : "function" +>this.props.thumbYProps!.elementRef(ref) : void +>this.props.thumbYProps!.elementRef : ElementRef +>this.props.thumbYProps! : ThumbProps +>this.props.thumbYProps : ThumbProps | undefined +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbYProps : ThumbProps | undefined +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref); +>typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref) : false | void +>typeof (this.props.thumbYProps!.elementRef) === 'function' : boolean +>typeof (this.props.thumbYProps!.elementRef) : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>(this.props.thumbYProps!.elementRef) : ElementRef | undefined +>this.props.thumbYProps!.elementRef : ElementRef | undefined +>this.props.thumbYProps! : ThumbProps +>this.props.thumbYProps : ThumbProps | undefined +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbYProps : ThumbProps | undefined +>elementRef : ElementRef | undefined +>'function' : "function" +>this.props.thumbYProps!.elementRef(ref) : void +>this.props.thumbYProps!.elementRef : ElementRef +>this.props.thumbYProps! : ThumbProps +>this.props.thumbYProps : ThumbProps | undefined +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbYProps : ThumbProps | undefined +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref); +>typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref) : false | void +>typeof ((this.props).thumbYProps!.elementRef)! === 'function' : boolean +>typeof ((this.props).thumbYProps!.elementRef)! : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>((this.props).thumbYProps!.elementRef)! : ElementRef +>((this.props).thumbYProps!.elementRef) : ElementRef | undefined +>(this.props).thumbYProps!.elementRef : ElementRef | undefined +>(this.props).thumbYProps! : ThumbProps +>(this.props).thumbYProps : ThumbProps | undefined +>(this.props) : ComponentProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbYProps : ThumbProps | undefined +>elementRef : ElementRef | undefined +>'function' : "function" +>this.props.thumbYProps!.elementRef(ref) : void +>this.props.thumbYProps!.elementRef : ElementRef +>this.props.thumbYProps! : ThumbProps +>this.props.thumbYProps : ThumbProps | undefined +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbYProps : ThumbProps | undefined +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref); +>typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref) : false | void +>typeof this.props.thumbXProps.elementRef === 'function' : boolean +>typeof this.props.thumbXProps.elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>this.props.thumbXProps.elementRef : ElementRef | undefined +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef | undefined +>'function' : "function" +>this.props.thumbXProps.elementRef(ref) : void +>this.props.thumbXProps.elementRef : ElementRef +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref); +>typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref) : false | void +>typeof this.props.thumbXProps.elementRef === 'function' : boolean +>typeof this.props.thumbXProps.elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>this.props.thumbXProps.elementRef : ElementRef | undefined +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef | undefined +>'function' : "function" +>(this.props).thumbXProps.elementRef(ref) : void +>(this.props).thumbXProps.elementRef : ElementRef +>(this.props).thumbXProps : ThumbProps +>(this.props) : ComponentProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref); +>typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref) : false | void +>typeof this.props.thumbXProps.elementRef === 'function' : boolean +>typeof this.props.thumbXProps.elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>this.props.thumbXProps.elementRef : ElementRef | undefined +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef | undefined +>'function' : "function" +>(this.props.thumbXProps).elementRef(ref) : void +>(this.props.thumbXProps).elementRef : ElementRef +>(this.props.thumbXProps) : ThumbProps +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); +>typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref) : false | void +>typeof this.props.thumbXProps.elementRef === 'function' : boolean +>typeof this.props.thumbXProps.elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>this.props.thumbXProps.elementRef : ElementRef | undefined +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef | undefined +>'function' : "function" +>((this.props)!.thumbXProps)!.elementRef(ref) : void +>((this.props)!.thumbXProps)!.elementRef : ElementRef +>((this.props)!.thumbXProps)! : ThumbProps +>((this.props)!.thumbXProps) : ThumbProps +>(this.props)!.thumbXProps : ThumbProps +>(this.props)! : ComponentProps +>(this.props) : ComponentProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); +>typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref) : false | void +>typeof (this.props.thumbXProps).elementRef === 'function' : boolean +>typeof (this.props.thumbXProps).elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>(this.props.thumbXProps).elementRef : ElementRef | undefined +>(this.props.thumbXProps) : ThumbProps +>this.props.thumbXProps : ThumbProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef | undefined +>'function' : "function" +>((this.props)!.thumbXProps)!.elementRef(ref) : void +>((this.props)!.thumbXProps)!.elementRef : ElementRef +>((this.props)!.thumbXProps)! : ThumbProps +>((this.props)!.thumbXProps) : ThumbProps +>(this.props)!.thumbXProps : ThumbProps +>(this.props)! : ComponentProps +>(this.props) : ComponentProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef +>ref : HTMLElement | null + + typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); +>typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref) : false | void +>typeof this.props!.thumbXProps!.elementRef === 'function' : boolean +>typeof this.props!.thumbXProps!.elementRef : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>this.props!.thumbXProps!.elementRef : ElementRef | undefined +>this.props!.thumbXProps! : ThumbProps +>this.props!.thumbXProps : ThumbProps +>this.props! : ComponentProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef | undefined +>'function' : "function" +>((this.props)!.thumbXProps)!.elementRef(ref) : void +>((this.props)!.thumbXProps)!.elementRef : ElementRef +>((this.props)!.thumbXProps)! : ThumbProps +>((this.props)!.thumbXProps) : ThumbProps +>(this.props)!.thumbXProps : ThumbProps +>(this.props)! : ComponentProps +>(this.props) : ComponentProps +>this.props : ComponentProps +>this : this +>props : ComponentProps +>thumbXProps : ThumbProps +>elementRef : ElementRef +>ref : HTMLElement | null + + }; +} diff --git a/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.js b/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.js new file mode 100644 index 00000000000..377082fa5d5 --- /dev/null +++ b/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.ts] //// + +//// [global.d.ts] +declare global { + const React: typeof import("./module"); +} + +export { }; + +//// [module.d.ts] +export = React; +export as namespace React; + +declare namespace React { + function createRef(): any; +} + +//// [some_module.ts] +export { }; +React.createRef; + +//// [emits.ts] +console.log("hello"); +React.createRef; + +//// [some_module.js] +React.createRef; +//// [emits.js] +"use strict"; +console.log("hello"); +React.createRef; diff --git a/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.symbols b/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.symbols new file mode 100644 index 00000000000..24a9885b294 --- /dev/null +++ b/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.symbols @@ -0,0 +1,42 @@ +=== tests/cases/compiler/global.d.ts === +declare global { +>global : Symbol(global, Decl(global.d.ts, 0, 0)) + + const React: typeof import("./module"); +>React : Symbol(React, Decl(module.d.ts, 1, 26), Decl(global.d.ts, 1, 9)) +} + +export { }; + +=== tests/cases/compiler/module.d.ts === +export = React; +>React : Symbol(React, Decl(module.d.ts, 1, 26)) + +export as namespace React; +>React : Symbol(React, Decl(module.d.ts, 0, 15)) + +declare namespace React { +>React : Symbol(React, Decl(module.d.ts, 1, 26), Decl(global.d.ts, 1, 9)) + + function createRef(): any; +>createRef : Symbol(createRef, Decl(module.d.ts, 3, 25)) +} + +=== tests/cases/compiler/some_module.ts === +export { }; +React.createRef; +>React.createRef : Symbol(React.createRef, Decl(module.d.ts, 3, 25)) +>React : Symbol(React, Decl(module.d.ts, 1, 26), Decl(global.d.ts, 1, 9)) +>createRef : Symbol(React.createRef, Decl(module.d.ts, 3, 25)) + +=== tests/cases/compiler/emits.ts === +console.log("hello"); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) + +React.createRef; +>React.createRef : Symbol(React.createRef, Decl(module.d.ts, 3, 25)) +>React : Symbol(React, Decl(module.d.ts, 1, 26), Decl(global.d.ts, 1, 9)) +>createRef : Symbol(React.createRef, Decl(module.d.ts, 3, 25)) + diff --git a/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.types b/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.types new file mode 100644 index 00000000000..2c0ce91aec8 --- /dev/null +++ b/tests/baselines/reference/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/global.d.ts === +declare global { +>global : typeof global + + const React: typeof import("./module"); +>React : typeof React +} + +export { }; + +=== tests/cases/compiler/module.d.ts === +export = React; +>React : typeof React + +export as namespace React; +>React : typeof React + +declare namespace React { +>React : typeof React + + function createRef(): any; +>createRef : () => any +} + +=== tests/cases/compiler/some_module.ts === +export { }; +React.createRef; +>React.createRef : () => any +>React : typeof React +>createRef : () => any + +=== tests/cases/compiler/emits.ts === +console.log("hello"); +>console.log("hello") : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>"hello" : "hello" + +React.createRef; +>React.createRef : () => any +>React : typeof React +>createRef : () => any + diff --git a/tests/baselines/reference/user/puppeteer.log b/tests/baselines/reference/user/puppeteer.log index 9d6c2b26482..30875ee5560 100644 --- a/tests/baselines/reference/user/puppeteer.log +++ b/tests/baselines/reference/user/puppeteer.log @@ -62,9 +62,9 @@ lib/Page.js(936,3): error TS2322: Type '{ width: number; height: number; }' is n lib/Page.js(937,3): error TS2322: Type '{ width: number; height: number; }' is not assignable to type 'string'. lib/Page.js(938,3): error TS2322: Type '{ width: number; height: number; }' is not assignable to type 'string'. lib/TaskQueue.js(7,14): error TS7014: Function type, which lacks return-type annotation, implicitly has an 'any' return type. -lib/externs.d.ts(3,29): error TS2497: Module '"/puppeteer/puppeteer/lib/Target"' resolves to a non-module entity and cannot be imported using this construct. -lib/externs.d.ts(5,32): error TS2497: Module '"/puppeteer/puppeteer/lib/TaskQueue"' resolves to a non-module entity and cannot be imported using this construct. -lib/externs.d.ts(9,37): error TS2497: Module '"/puppeteer/puppeteer/lib/ElementHandle"' resolves to a non-module entity and cannot be imported using this construct. +lib/externs.d.ts(3,29): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'allowSyntheticDefaultImports' flag and referencing its default export. +lib/externs.d.ts(5,32): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'allowSyntheticDefaultImports' flag and referencing its default export. +lib/externs.d.ts(9,37): error TS2497: This module can only be referenced with ECMAScript imports/exports by turning on the 'allowSyntheticDefaultImports' flag and referencing its default export. lib/externs.d.ts(16,26): error TS2503: Cannot find namespace 'Protocol'. lib/externs.d.ts(16,69): error TS2503: Cannot find namespace 'Protocol'. lib/externs.d.ts(17,28): error TS2503: Cannot find namespace 'Protocol'. diff --git a/tests/cases/compiler/checkSuperCallBeforeThisAccessing9.ts b/tests/cases/compiler/checkSuperCallBeforeThisAccessing9.ts new file mode 100644 index 00000000000..a6b7102b2a5 --- /dev/null +++ b/tests/cases/compiler/checkSuperCallBeforeThisAccessing9.ts @@ -0,0 +1,21 @@ +// @allowJs: true +// @checkJs: true +// @noEmit: true + +// @filename: noSuperInJSDocExtends.js +class Based { } +/** @extends {Based} */ +class Derived { + constructor() { + this; + this.x = 10; + var that = this; + } +} + +/** @extends {Based} */ +class Derived2 { + constructor() { + super(); + } +} \ No newline at end of file diff --git a/tests/cases/compiler/decoratorWithNegativeLiteralTypeNoCrash.ts b/tests/cases/compiler/decoratorWithNegativeLiteralTypeNoCrash.ts new file mode 100644 index 00000000000..720b68a7c16 --- /dev/null +++ b/tests/cases/compiler/decoratorWithNegativeLiteralTypeNoCrash.ts @@ -0,0 +1,8 @@ +// @target: es5 +// @experimentalDecorators: true +// @emitDecoratorMetadata: true +class A { + @decorator + public field1: -1 = -1; +} +function decorator(target: any, field: any) {} \ No newline at end of file diff --git a/tests/cases/compiler/es6ImportEqualsExportModuleCommonJsError.ts b/tests/cases/compiler/es6ImportEqualsExportModuleCommonJsError.ts new file mode 100644 index 00000000000..577e606c249 --- /dev/null +++ b/tests/cases/compiler/es6ImportEqualsExportModuleCommonJsError.ts @@ -0,0 +1,11 @@ +// @module: commonjs + +// @filename: a.ts +class a { } +export = a; + +// @filename: main.ts +import * as a from "./a"; +a; + + diff --git a/tests/cases/compiler/es6ImportEqualsExportModuleEs2015Error.ts b/tests/cases/compiler/es6ImportEqualsExportModuleEs2015Error.ts new file mode 100644 index 00000000000..a5505b0e90e --- /dev/null +++ b/tests/cases/compiler/es6ImportEqualsExportModuleEs2015Error.ts @@ -0,0 +1,11 @@ +// @module: es2015 + +// @filename: a.ts +class a { } +export = a; + +// @filename: main.ts +import * as a from "./a"; +a; + + diff --git a/tests/cases/compiler/nonNullReferenceMatching.ts b/tests/cases/compiler/nonNullReferenceMatching.ts new file mode 100644 index 00000000000..1295c3ce9a7 --- /dev/null +++ b/tests/cases/compiler/nonNullReferenceMatching.ts @@ -0,0 +1,34 @@ +// @strict: true +type ElementRef = (element: HTMLElement | null) => void; + +type ThumbProps = { + elementRef?: ElementRef; +} + +type ComponentProps = { + thumbYProps?: ThumbProps; + thumbXProps: ThumbProps; +} + +class Component { + props!: ComponentProps; + public thumbYElementRef = (ref: HTMLElement | null) => { + typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref); + + typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref); + + typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref); + + typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); + + typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); + + typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref); + }; +} \ No newline at end of file diff --git a/tests/cases/compiler/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.ts b/tests/cases/compiler/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.ts new file mode 100644 index 00000000000..81346aca1b4 --- /dev/null +++ b/tests/cases/compiler/umdNamespaceMergedWithGlobalAugmentationIsNotCircular.ts @@ -0,0 +1,26 @@ +// @strict: true +// @module: esnext +// @moduleResolution: node +// @target: es2018 +// @filename: global.d.ts +declare global { + const React: typeof import("./module"); +} + +export { }; + +// @filename: module.d.ts +export = React; +export as namespace React; + +declare namespace React { + function createRef(): any; +} + +// @filename: some_module.ts +export { }; +React.createRef; + +// @filename: emits.ts +console.log("hello"); +React.createRef; \ No newline at end of file diff --git a/tests/cases/conformance/declarationEmit/libReferenceNoLib.ts b/tests/cases/conformance/declarationEmit/libReferenceNoLib.ts new file mode 100644 index 00000000000..d29da9a5bc5 --- /dev/null +++ b/tests/cases/conformance/declarationEmit/libReferenceNoLib.ts @@ -0,0 +1,21 @@ +// @target: esnext +// @module: commonjs +// @noLib: true +// @declaration: true +// Test that passing noLib disables resolution. + +// @filename: fakelib.ts +interface Object { } +interface Array { } +interface String { } +interface Boolean { } +interface Number { } +interface Function { } +interface RegExp { } +interface IArguments { } + + +// @filename: file1.ts +/// +export declare interface HTMLElement { field: string; } +export const elem: HTMLElement = { field: 'a' }; diff --git a/tests/cases/conformance/declarationEmit/libReferenceNoLibBundle.ts b/tests/cases/conformance/declarationEmit/libReferenceNoLibBundle.ts new file mode 100644 index 00000000000..18f0b5387c5 --- /dev/null +++ b/tests/cases/conformance/declarationEmit/libReferenceNoLibBundle.ts @@ -0,0 +1,23 @@ +// @target: esnext +// @module: amd +// @noLib: true +// @declaration: true +// @outFile: bundle.js + +// Test that passing noLib disables resolution. + +// @filename: fakelib.ts +interface Object { } +interface Array { } +interface String { } +interface Boolean { } +interface Number { } +interface Function { } +interface RegExp { } +interface IArguments { } + + +// @filename: file1.ts +/// +export declare interface HTMLElement { field: string; } +export const elem: HTMLElement = { field: 'a' }; diff --git a/tests/cases/conformance/types/conditional/conditionalTypes1.ts b/tests/cases/conformance/types/conditional/conditionalTypes1.ts index f5c67f678eb..2e8690a228b 100644 --- a/tests/cases/conformance/types/conditional/conditionalTypes1.ts +++ b/tests/cases/conformance/types/conditional/conditionalTypes1.ts @@ -353,3 +353,11 @@ declare function assign(o: T, a: RecursivePartial): void; var a = {o: 1, b: 2, c: [{a: 1, c: '213'}]} assign(a, {o: 2, c: {0: {a: 2, c: '213123'}}}) + +// Repros from #23843 + +type Weird1 = ((a: U) => never) extends + ((a: U) => never) ? never : never; + +type Weird2 = ((a: U) => U) extends + ((a: U) => infer T) ? T : never; diff --git a/tests/cases/fourslash/codefixEnableExperimentalDecorators_blankCompilerOptions.ts b/tests/cases/fourslash/codefixEnableExperimentalDecorators_blankCompilerOptions.ts new file mode 100644 index 00000000000..0e19b42d921 --- /dev/null +++ b/tests/cases/fourslash/codefixEnableExperimentalDecorators_blankCompilerOptions.ts @@ -0,0 +1,26 @@ +/// + +// @Filename: /dir/a.ts +////declare const decorator: any; +////class A { +//// @decorator method() {}; +////}; + +// @Filename: /dir/tsconfig.json +////{ +//// "compilerOptions": { +//// } +////} + +goTo.file("/dir/a.ts"); +verify.codeFix({ + description: "Enable the 'experimentalDecorators' option in your configuration file", + newFileContent: { + "/dir/tsconfig.json": +`{ + "compilerOptions": { + "experimentalDecorators": true, + } +}`, + }, +}); diff --git a/tests/cases/fourslash/codefixEnableExperimentalDecorators_disabledInCompilerOptions.ts b/tests/cases/fourslash/codefixEnableExperimentalDecorators_disabledInCompilerOptions.ts new file mode 100644 index 00000000000..056e7e15a48 --- /dev/null +++ b/tests/cases/fourslash/codefixEnableExperimentalDecorators_disabledInCompilerOptions.ts @@ -0,0 +1,27 @@ +/// + +// @Filename: /dir/a.ts +////declare const decorator: any; +////class A { +//// @decorator method() {}; +////}; + +// @Filename: /dir/tsconfig.json +////{ +//// "compilerOptions": { +//// "experimentalDecorators": false, +//// } +////} + +goTo.file("/dir/a.ts"); +verify.codeFix({ + description: "Enable the 'experimentalDecorators' option in your configuration file", + newFileContent: { + "/dir/tsconfig.json": +`{ + "compilerOptions": { + "experimentalDecorators": true, + } +}`, + }, +}); diff --git a/tests/cases/fourslash/codefixEnableExperimentalDecorators_missingCompilerOptions.ts b/tests/cases/fourslash/codefixEnableExperimentalDecorators_missingCompilerOptions.ts new file mode 100644 index 00000000000..6d7006f3ce1 --- /dev/null +++ b/tests/cases/fourslash/codefixEnableExperimentalDecorators_missingCompilerOptions.ts @@ -0,0 +1,22 @@ +/// + +// @Filename: /dir/a.ts +////declare const decorator: any; +////class A { +//// @decorator method() {}; +////}; + +// @Filename: /dir/tsconfig.json +////{ +////} + +goTo.file("/dir/a.ts"); +verify.codeFix({ + description: "Enable the 'experimentalDecorators' option in your configuration file", + newFileContent: { + "/dir/tsconfig.json": +`{ + "compilerOptions": { "experimentalDecorators": true }, +}`, + }, +}); diff --git a/tests/cases/fourslash/codefixEnableExperimentalDecorators_noTsconfig.ts b/tests/cases/fourslash/codefixEnableExperimentalDecorators_noTsconfig.ts new file mode 100644 index 00000000000..8430fd0734b --- /dev/null +++ b/tests/cases/fourslash/codefixEnableExperimentalDecorators_noTsconfig.ts @@ -0,0 +1,10 @@ +/// + +// @Filename: /dir/a.ts +////declare const decorator: any; +////class A { +//// @decorator method() {}; +////}; + +goTo.file("/dir/a.ts"); +verify.not.codeFixAvailable(); diff --git a/tests/cases/fourslash/completionListBuilderLocations_Modules.ts b/tests/cases/fourslash/completionListBuilderLocations_Modules.ts index a98d65e255d..29530ccbdef 100644 --- a/tests/cases/fourslash/completionListBuilderLocations_Modules.ts +++ b/tests/cases/fourslash/completionListBuilderLocations_Modules.ts @@ -7,5 +7,5 @@ verify.completions( { marker: "moduleName1", exact: completion.globals, isNewIdentifierLocation: true }, - { marker: "moduleName2", exact: undefined }, + { marker: "moduleName2", exact: [], isNewIdentifierLocation: true }, );