diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index beb75fd16d2dc..01732be6ed2fb 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1448,6 +1448,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny"); var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis"); var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); + // Enabling flag by default for testing, do not merge as-is + var strictInstanceOfTypeParameters = true; var keyofStringsOnly = !!compilerOptions.keyofStringsOnly; var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : ObjectFlags.FreshLiteral; var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes; @@ -10136,13 +10138,35 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { })!.parent; } + function getInstanceTypeOfClassSymbol(classSymbol: Symbol): Type { + const classType = getDeclaredTypeOfSymbol(classSymbol) as GenericType; + const objectFlags = getObjectFlags(classType); + if (!(objectFlags & ObjectFlags.ClassOrInterface) || !classType.typeParameters) { + return classType; + } + const variances = getVariances(classType); + const typeArguments = map(classType.typeParameters, (typeParameter, i) => { + if (!strictInstanceOfTypeParameters) { + return anyType; + } + const variance = variances[i]; + switch (variance & VarianceFlags.VarianceMask) { + case VarianceFlags.Contravariant: + case VarianceFlags.Bivariant: + return neverType; + } + return getBaseConstraintOfType(typeParameter) || unknownType; + }); + return createTypeReference(classType, typeArguments); + } + function getTypeOfPrototypeProperty(prototype: Symbol): Type { - // TypeScript 1.0 spec (April 2014): 8.4 // Every class automatically contains a static property member named 'prototype', - // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter. + // the type of which is an instantiation of the class type. + // Type parameters on this class are instantiated with a type based on their constraint and variance. // It is an error to explicitly declare a static property member with the name 'prototype'. - const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype)!) as InterfaceType; - return classType.typeParameters ? createTypeReference(classType as GenericType, map(classType.typeParameters, _ => anyType)) : classType; + const classSymbol = getParentOfSymbol(prototype)!; + return getInstanceTypeOfClassSymbol(classSymbol); } // Return the type of the given property in the given type, or undefined if no such property exists @@ -26951,10 +26975,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (symbol === undefined) { return type; } - const classSymbol = symbol.parent!; + const classSymbol = getParentOfSymbol(symbol)!; const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) as InterfaceType - : getDeclaredTypeOfSymbol(classSymbol); + : getInstanceTypeOfClassSymbol(classSymbol); return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true); } diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 629063de29808..b5dd35d728f7f 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -881,6 +881,16 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [ description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any, defaultValueDescription: false, }, + { + name: "strictInstanceOfTypeParameters", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsBuildInfo: true, + strictFlag: true, + category: Diagnostics.Type_Checking, + description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks, + defaultValueDescription: false, + }, { name: "alwaysStrict", type: "boolean", diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 267a7e635d251..74b4331c5f151 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -6071,7 +6071,10 @@ "category": "Message", "code": 6804 }, - + "Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks.": { + "category": "Message", + "code": 6805 + }, "one of:": { "category": "Message", "code": 6900 diff --git a/src/compiler/types.ts b/src/compiler/types.ts index df0ba774ae5b3..53bb1dc36acbe 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -7108,6 +7108,7 @@ export interface CompilerOptions { strictBindCallApply?: boolean; // Always combine with strict property strictNullChecks?: boolean; // Always combine with strict property strictPropertyInitialization?: boolean; // Always combine with strict property + strictInstanceOfTypeParameters?: boolean; stripInternal?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index af4730f848460..1701d08255eba 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -8490,6 +8490,7 @@ export type StrictOptionName = | "strictPropertyInitialization" | "alwaysStrict" | "useUnknownInCatchVariables" + | "strictInstanceOfTypeParameters" ; /** @internal */ diff --git a/tests/baselines/reference/accessorsOverrideProperty9.types b/tests/baselines/reference/accessorsOverrideProperty9.types index dcbc3523e10cd..730bb95d4d710 100644 --- a/tests/baselines/reference/accessorsOverrideProperty9.types +++ b/tests/baselines/reference/accessorsOverrideProperty9.types @@ -68,7 +68,7 @@ function ApiItemContainerMixin( } return MixedClass; ->MixedClass : ((abstract new (...args: any[]) => MixedClass) & { prototype: ApiItemContainerMixin.MixedClass; }) & TBaseClass +>MixedClass : ((abstract new (...args: any[]) => MixedClass) & { prototype: ApiItemContainerMixin.MixedClass; }) & TBaseClass } // Subclass inheriting from mixin diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 34006d63b2ea5..3c22d6e51872a 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -7135,6 +7135,7 @@ declare namespace ts { strictBindCallApply?: boolean; strictNullChecks?: boolean; strictPropertyInitialization?: boolean; + strictInstanceOfTypeParameters?: boolean; stripInternal?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 2201712f7c4eb..f0932c432fcb4 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -3160,6 +3160,7 @@ declare namespace ts { strictBindCallApply?: boolean; strictNullChecks?: boolean; strictPropertyInitialization?: boolean; + strictInstanceOfTypeParameters?: boolean; stripInternal?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; diff --git a/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json index e075f973c4d28..83dd007301215 100644 --- a/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json index e075f973c4d28..83dd007301215 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json index e075f973c4d28..83dd007301215 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json index 3379ad1a3b576..266d624718748 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json index e9e873054b703..7442148fe7dd7 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json index 178abdeca2791..84cad0e5aa8c9 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json index 6136a0e0ce953..12c9188f89c02 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json index 84bdc4354ee70..977e53dcd7482 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json index e075f973c4d28..83dd007301215 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json index 8b051d2b3dd93..37b0a703cd96a 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json index c0c664e0d7c8a..1f753028b091d 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json @@ -90,6 +90,7 @@ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ diff --git a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json new file mode 100644 index 0000000000000..06dd3dbb77ab6 --- /dev/null +++ b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "strictInstanceOfTypeParameters": true + } +} diff --git a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json new file mode 100644 index 0000000000000..06dd3dbb77ab6 --- /dev/null +++ b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "strictInstanceOfTypeParameters": true + } +} diff --git a/tests/baselines/reference/expressionWithJSDocTypeArguments.types b/tests/baselines/reference/expressionWithJSDocTypeArguments.types index 9733f5a1b118d..5d9dfc4e5370b 100644 --- a/tests/baselines/reference/expressionWithJSDocTypeArguments.types +++ b/tests/baselines/reference/expressionWithJSDocTypeArguments.types @@ -49,23 +49,23 @@ type TComeOnFoo = typeof foo; >foo : (x: T) => T const WhatBar = Bar; ->WhatBar : { new (x: any): Bar; prototype: Bar; } ->Bar : { new (x: any): Bar; prototype: Bar; } +>WhatBar : { new (x: any): Bar; prototype: Bar; } +>Bar : { new (x: any): Bar; prototype: Bar; } >Bar : typeof Bar const HuhBar = Bar; ->HuhBar : { new (x: string | null): Bar; prototype: Bar; } ->Bar : { new (x: string | null): Bar; prototype: Bar; } +>HuhBar : { new (x: string | null): Bar; prototype: Bar; } +>Bar : { new (x: string | null): Bar; prototype: Bar; } >Bar : typeof Bar const NopeBar = Bar; ->NopeBar : { new (x: string | null): Bar; prototype: Bar; } ->Bar : { new (x: string | null): Bar; prototype: Bar; } +>NopeBar : { new (x: string | null): Bar; prototype: Bar; } +>Bar : { new (x: string | null): Bar; prototype: Bar; } >Bar : typeof Bar const ComeOnBar = Bar; ->ComeOnBar : { new (x: string | null): Bar; prototype: Bar; } ->Bar : { new (x: string | null): Bar; prototype: Bar; } +>ComeOnBar : { new (x: string | null): Bar; prototype: Bar; } +>Bar : { new (x: string | null): Bar; prototype: Bar; } >Bar : typeof Bar type TWhatBar = typeof Bar; diff --git a/tests/baselines/reference/instantiationExpressions.errors.txt b/tests/baselines/reference/instantiationExpressions.errors.txt index d4af975c75fc2..b5027b22e26cd 100644 --- a/tests/baselines/reference/instantiationExpressions.errors.txt +++ b/tests/baselines/reference/instantiationExpressions.errors.txt @@ -67,7 +67,7 @@ tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpr } function f3() { - let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } + let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } let f1 = C.f; // (x: string) => string[] } diff --git a/tests/baselines/reference/instantiationExpressions.js b/tests/baselines/reference/instantiationExpressions.js index d10ef4b73f3f0..fa921779aefa2 100644 --- a/tests/baselines/reference/instantiationExpressions.js +++ b/tests/baselines/reference/instantiationExpressions.js @@ -31,7 +31,7 @@ declare class C { } function f3() { - let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } + let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } let f1 = C.f; // (x: string) => string[] } @@ -187,7 +187,7 @@ function f2() { var A2 = (Array); // Error } function f3() { - var c1 = (C); // { new (x: string): C; f(x: U): T[]; prototype: C; } + var c1 = (C); // { new (x: string): C; f(x: U): T[]; prototype: C; } var f1 = (C.f); // (x: string) => string[] } function f10(f) { diff --git a/tests/baselines/reference/instantiationExpressions.symbols b/tests/baselines/reference/instantiationExpressions.symbols index 3fd52bf485bc2..c7e1dc991e767 100644 --- a/tests/baselines/reference/instantiationExpressions.symbols +++ b/tests/baselines/reference/instantiationExpressions.symbols @@ -107,7 +107,7 @@ declare class C { function f3() { >f3 : Symbol(f3, Decl(instantiationExpressions.ts, 29, 1)) - let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } + let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } >c1 : Symbol(c1, Decl(instantiationExpressions.ts, 32, 7)) >C : Symbol(C, Decl(instantiationExpressions.ts, 24, 40)) diff --git a/tests/baselines/reference/instantiationExpressions.types b/tests/baselines/reference/instantiationExpressions.types index 7b85e85e82cc6..5da8dd2880568 100644 --- a/tests/baselines/reference/instantiationExpressions.types +++ b/tests/baselines/reference/instantiationExpressions.types @@ -97,9 +97,9 @@ declare class C { function f3() { >f3 : () => void - let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } ->c1 : { new (x: string): C; prototype: C; f(x: U): U[]; } ->C : { new (x: string): C; prototype: C; f(x: U): U[]; } + let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } +>c1 : { new (x: string): C; prototype: C; f(x: U): U[]; } +>C : { new (x: string): C; prototype: C; f(x: U): U[]; } >C : typeof C let f1 = C.f; // (x: string) => string[] diff --git a/tests/baselines/reference/overrideBaseIntersectionMethod.types b/tests/baselines/reference/overrideBaseIntersectionMethod.types index 3ca80a06a1a78..be5ffbb3c8028 100644 --- a/tests/baselines/reference/overrideBaseIntersectionMethod.types +++ b/tests/baselines/reference/overrideBaseIntersectionMethod.types @@ -6,10 +6,10 @@ type Constructor = new (...args: any[]) => T; >args : any[] const WithLocation = >(Base: T) => class extends Base { ->WithLocation : >(Base: T) => { new (...args: any[]): (Anonymous class); prototype: WithLocation.(Anonymous class); } & T ->>(Base: T) => class extends Base { getLocation(): [number, number] { const [x,y] = super.getLocation(); return [this.x | x, this.y | y]; }} : >(Base: T) => { new (...args: any[]): (Anonymous class); prototype: WithLocation.(Anonymous class); } & T +>WithLocation : >(Base: T) => { new (...args: any[]): (Anonymous class); prototype: WithLocation>.(Anonymous class); } & T +>>(Base: T) => class extends Base { getLocation(): [number, number] { const [x,y] = super.getLocation(); return [this.x | x, this.y | y]; }} : >(Base: T) => { new (...args: any[]): (Anonymous class); prototype: WithLocation>.(Anonymous class); } & T >Base : T ->class extends Base { getLocation(): [number, number] { const [x,y] = super.getLocation(); return [this.x | x, this.y | y]; }} : { new (...args: any[]): (Anonymous class); prototype: WithLocation.(Anonymous class); } & T +>class extends Base { getLocation(): [number, number] { const [x,y] = super.getLocation(); return [this.x | x, this.y | y]; }} : { new (...args: any[]): (Anonymous class); prototype: WithLocation>.(Anonymous class); } & T >Base : Point getLocation(): [number, number] { @@ -58,7 +58,7 @@ class Point { class Foo extends WithLocation(Point) { >Foo : Foo >WithLocation(Point) : WithLocation.(Anonymous class) & Point ->WithLocation : >(Base: T) => { new (...args: any[]): (Anonymous class); prototype: WithLocation.(Anonymous class); } & T +>WithLocation : >(Base: T) => { new (...args: any[]): (Anonymous class); prototype: WithLocation>.(Anonymous class); } & T >Point : typeof Point calculate() { diff --git a/tests/baselines/reference/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json b/tests/baselines/reference/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json new file mode 100644 index 0000000000000..06dd3dbb77ab6 --- /dev/null +++ b/tests/baselines/reference/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "strictInstanceOfTypeParameters": true + } +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt new file mode 100644 index 0000000000000..ce04f334149f1 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt @@ -0,0 +1,54 @@ +tests/cases/compiler/strictInstanceOfTypeParameters.ts(9,13): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. +tests/cases/compiler/strictInstanceOfTypeParameters.ts(10,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. +tests/cases/compiler/strictInstanceOfTypeParameters.ts(11,7): error TS2349: This expression is not callable. + Type '{}' has no call signatures. +tests/cases/compiler/strictInstanceOfTypeParameters.ts(35,12): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== tests/cases/compiler/strictInstanceOfTypeParameters.ts (4 errors) ==== + class Unconstrained { + value: T; + read: (value: T) => void; + } + + declare const x: unknown; + + if (x instanceof Unconstrained) { + x.value.toUpperCase(); + ~~~~~~~~~~~ +!!! error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. + x.value++; + ~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. + x.value(); + ~~~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type '{}' has no call signatures. + + if (typeof x.value === "string") { + x.value.toUpperCase(); + } + if (typeof x.value === "number") { + x.value++; + } + + x.read(1); + x.read("foo"); + } + + class Constrained { + value: T; + read: (value: T) => void; + } + + declare const y: unknown; + + if (y instanceof Constrained) { + y.value++; + + y.read(1); + y.read("foo"); + ~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/strictInstanceOfTypeParameters.js b/tests/baselines/reference/strictInstanceOfTypeParameters.js new file mode 100644 index 0000000000000..c4ff3957bad47 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.js @@ -0,0 +1,68 @@ +//// [strictInstanceOfTypeParameters.ts] +class Unconstrained { + value: T; + read: (value: T) => void; +} + +declare const x: unknown; + +if (x instanceof Unconstrained) { + x.value.toUpperCase(); + x.value++; + x.value(); + + if (typeof x.value === "string") { + x.value.toUpperCase(); + } + if (typeof x.value === "number") { + x.value++; + } + + x.read(1); + x.read("foo"); +} + +class Constrained { + value: T; + read: (value: T) => void; +} + +declare const y: unknown; + +if (y instanceof Constrained) { + y.value++; + + y.read(1); + y.read("foo"); +} + + +//// [strictInstanceOfTypeParameters.js] +var Unconstrained = /** @class */ (function () { + function Unconstrained() { + } + return Unconstrained; +}()); +if (x instanceof Unconstrained) { + x.value.toUpperCase(); + x.value++; + x.value(); + if (typeof x.value === "string") { + x.value.toUpperCase(); + } + if (typeof x.value === "number") { + x.value++; + } + x.read(1); + x.read("foo"); +} +var Constrained = /** @class */ (function () { + function Constrained() { + } + return Constrained; +}()); +if (y instanceof Constrained) { + y.value++; + y.read(1); + y.read("foo"); +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParameters.symbols b/tests/baselines/reference/strictInstanceOfTypeParameters.symbols new file mode 100644 index 0000000000000..dc7cab90a0e45 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.symbols @@ -0,0 +1,108 @@ +=== tests/cases/compiler/strictInstanceOfTypeParameters.ts === +class Unconstrained { +>Unconstrained : Symbol(Unconstrained, Decl(strictInstanceOfTypeParameters.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParameters.ts, 0, 20)) + + value: T; +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>T : Symbol(T, Decl(strictInstanceOfTypeParameters.ts, 0, 20)) + + read: (value: T) => void; +>read : Symbol(Unconstrained.read, Decl(strictInstanceOfTypeParameters.ts, 1, 13)) +>value : Symbol(value, Decl(strictInstanceOfTypeParameters.ts, 2, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParameters.ts, 0, 20)) +} + +declare const x: unknown; +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) + +if (x instanceof Unconstrained) { +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>Unconstrained : Symbol(Unconstrained, Decl(strictInstanceOfTypeParameters.ts, 0, 0)) + + x.value.toUpperCase(); +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) + + x.value++; +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) + + x.value(); +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) + + if (typeof x.value === "string") { +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) + + x.value.toUpperCase(); +>x.value.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + } + if (typeof x.value === "number") { +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) + + x.value++; +>x.value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>value : Symbol(Unconstrained.value, Decl(strictInstanceOfTypeParameters.ts, 0, 24)) + } + + x.read(1); +>x.read : Symbol(Unconstrained.read, Decl(strictInstanceOfTypeParameters.ts, 1, 13)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>read : Symbol(Unconstrained.read, Decl(strictInstanceOfTypeParameters.ts, 1, 13)) + + x.read("foo"); +>x.read : Symbol(Unconstrained.read, Decl(strictInstanceOfTypeParameters.ts, 1, 13)) +>x : Symbol(x, Decl(strictInstanceOfTypeParameters.ts, 5, 13)) +>read : Symbol(Unconstrained.read, Decl(strictInstanceOfTypeParameters.ts, 1, 13)) +} + +class Constrained { +>Constrained : Symbol(Constrained, Decl(strictInstanceOfTypeParameters.ts, 21, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParameters.ts, 23, 18)) + + value: T; +>value : Symbol(Constrained.value, Decl(strictInstanceOfTypeParameters.ts, 23, 37)) +>T : Symbol(T, Decl(strictInstanceOfTypeParameters.ts, 23, 18)) + + read: (value: T) => void; +>read : Symbol(Constrained.read, Decl(strictInstanceOfTypeParameters.ts, 24, 13)) +>value : Symbol(value, Decl(strictInstanceOfTypeParameters.ts, 25, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParameters.ts, 23, 18)) +} + +declare const y: unknown; +>y : Symbol(y, Decl(strictInstanceOfTypeParameters.ts, 28, 13)) + +if (y instanceof Constrained) { +>y : Symbol(y, Decl(strictInstanceOfTypeParameters.ts, 28, 13)) +>Constrained : Symbol(Constrained, Decl(strictInstanceOfTypeParameters.ts, 21, 1)) + + y.value++; +>y.value : Symbol(Constrained.value, Decl(strictInstanceOfTypeParameters.ts, 23, 37)) +>y : Symbol(y, Decl(strictInstanceOfTypeParameters.ts, 28, 13)) +>value : Symbol(Constrained.value, Decl(strictInstanceOfTypeParameters.ts, 23, 37)) + + y.read(1); +>y.read : Symbol(Constrained.read, Decl(strictInstanceOfTypeParameters.ts, 24, 13)) +>y : Symbol(y, Decl(strictInstanceOfTypeParameters.ts, 28, 13)) +>read : Symbol(Constrained.read, Decl(strictInstanceOfTypeParameters.ts, 24, 13)) + + y.read("foo"); +>y.read : Symbol(Constrained.read, Decl(strictInstanceOfTypeParameters.ts, 24, 13)) +>y : Symbol(y, Decl(strictInstanceOfTypeParameters.ts, 28, 13)) +>read : Symbol(Constrained.read, Decl(strictInstanceOfTypeParameters.ts, 24, 13)) +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParameters.types b/tests/baselines/reference/strictInstanceOfTypeParameters.types new file mode 100644 index 0000000000000..c1de7c9aa9041 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.types @@ -0,0 +1,126 @@ +=== tests/cases/compiler/strictInstanceOfTypeParameters.ts === +class Unconstrained { +>Unconstrained : Unconstrained + + value: T; +>value : T + + read: (value: T) => void; +>read : (value: T) => void +>value : T +} + +declare const x: unknown; +>x : unknown + +if (x instanceof Unconstrained) { +>x instanceof Unconstrained : boolean +>x : unknown +>Unconstrained : typeof Unconstrained + + x.value.toUpperCase(); +>x.value.toUpperCase() : any +>x.value.toUpperCase : any +>x.value : unknown +>x : Unconstrained +>value : unknown +>toUpperCase : any + + x.value++; +>x.value++ : number +>x.value : unknown +>x : Unconstrained +>value : unknown + + x.value(); +>x.value() : any +>x.value : unknown +>x : Unconstrained +>value : unknown + + if (typeof x.value === "string") { +>typeof x.value === "string" : boolean +>typeof x.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>x.value : unknown +>x : Unconstrained +>value : unknown +>"string" : "string" + + x.value.toUpperCase(); +>x.value.toUpperCase() : string +>x.value.toUpperCase : () => string +>x.value : string +>x : Unconstrained +>value : string +>toUpperCase : () => string + } + if (typeof x.value === "number") { +>typeof x.value === "number" : boolean +>typeof x.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>x.value : unknown +>x : Unconstrained +>value : unknown +>"number" : "number" + + x.value++; +>x.value++ : number +>x.value : number +>x : Unconstrained +>value : number + } + + x.read(1); +>x.read(1) : void +>x.read : (value: unknown) => void +>x : Unconstrained +>read : (value: unknown) => void +>1 : 1 + + x.read("foo"); +>x.read("foo") : void +>x.read : (value: unknown) => void +>x : Unconstrained +>read : (value: unknown) => void +>"foo" : "foo" +} + +class Constrained { +>Constrained : Constrained + + value: T; +>value : T + + read: (value: T) => void; +>read : (value: T) => void +>value : T +} + +declare const y: unknown; +>y : unknown + +if (y instanceof Constrained) { +>y instanceof Constrained : boolean +>y : unknown +>Constrained : typeof Constrained + + y.value++; +>y.value++ : number +>y.value : number +>y : Constrained +>value : number + + y.read(1); +>y.read(1) : void +>y.read : (value: number) => void +>y : Constrained +>read : (value: number) => void +>1 : 1 + + y.read("foo"); +>y.read("foo") : void +>y.read : (value: number) => void +>y : Constrained +>read : (value: number) => void +>"foo" : "foo" +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt new file mode 100644 index 0000000000000..ab0967f3c1ecd --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt @@ -0,0 +1,36 @@ +tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts(9,13): error TS2322: Type 'unknown' is not assignable to type 'T'. + 'T' could be instantiated with an arbitrary type which could be unrelated to 'unknown'. +tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts(19,13): error TS2322: Type 'string' is not assignable to type 'T'. + 'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'string'. + + +==== tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts (2 errors) ==== + class UnconstrainedWithPrivate { + #brand; + value: T; + constructor(value: T) { + this.value = value; + } + copyValue(other: object) { + if (#brand in other) { + this.value = other.value; + ~~~~~~~~~~ +!!! error TS2322: Type 'unknown' is not assignable to type 'T'. +!!! error TS2322: 'T' could be instantiated with an arbitrary type which could be unrelated to 'unknown'. + } + } + } + + class ConstrainedWithPrivate { + #brand; + value: T; + copyValue(other: object) { + if (#brand in other) { + this.value = other.value; + ~~~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'T'. +!!! error TS2322: 'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'string'. + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.js b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.js new file mode 100644 index 0000000000000..c757472047c59 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.js @@ -0,0 +1,54 @@ +//// [strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts] +class UnconstrainedWithPrivate { + #brand; + value: T; + constructor(value: T) { + this.value = value; + } + copyValue(other: object) { + if (#brand in other) { + this.value = other.value; + } + } +} + +class ConstrainedWithPrivate { + #brand; + value: T; + copyValue(other: object) { + if (#brand in other) { + this.value = other.value; + } + } +} + + +//// [strictInstanceOfTypeParametersFromPrivateNameInInExpression.js] +var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) { + if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); + return typeof state === "function" ? receiver === state : state.has(receiver); +}; +var _UnconstrainedWithPrivate_brand, _ConstrainedWithPrivate_brand; +class UnconstrainedWithPrivate { + constructor(value) { + _UnconstrainedWithPrivate_brand.set(this, void 0); + this.value = value; + } + copyValue(other) { + if (__classPrivateFieldIn(_UnconstrainedWithPrivate_brand, other)) { + this.value = other.value; + } + } +} +_UnconstrainedWithPrivate_brand = new WeakMap(); +class ConstrainedWithPrivate { + constructor() { + _ConstrainedWithPrivate_brand.set(this, void 0); + } + copyValue(other) { + if (__classPrivateFieldIn(_ConstrainedWithPrivate_brand, other)) { + this.value = other.value; + } + } +} +_ConstrainedWithPrivate_brand = new WeakMap(); diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.symbols new file mode 100644 index 0000000000000..2d65ef804be6d --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.symbols @@ -0,0 +1,71 @@ +=== tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts === +class UnconstrainedWithPrivate { +>UnconstrainedWithPrivate : Symbol(UnconstrainedWithPrivate, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 31)) + + #brand; +>#brand : Symbol(UnconstrainedWithPrivate.#brand, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 35)) + + value: T; +>value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 31)) + + constructor(value: T) { +>value : Symbol(value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 3, 16)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 31)) + + this.value = value; +>this.value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) +>this : Symbol(UnconstrainedWithPrivate, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 0)) +>value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) +>value : Symbol(value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 3, 16)) + } + copyValue(other: object) { +>copyValue : Symbol(UnconstrainedWithPrivate.copyValue, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 5, 5)) +>other : Symbol(other, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 6, 14)) + + if (#brand in other) { +>#brand : Symbol(UnconstrainedWithPrivate.#brand, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 35)) +>other : Symbol(other, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 6, 14)) + + this.value = other.value; +>this.value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) +>this : Symbol(UnconstrainedWithPrivate, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 0, 0)) +>value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) +>other.value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) +>other : Symbol(other, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 6, 14)) +>value : Symbol(UnconstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 1, 11)) + } + } +} + +class ConstrainedWithPrivate { +>ConstrainedWithPrivate : Symbol(ConstrainedWithPrivate, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 11, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 13, 29)) + + #brand; +>#brand : Symbol(ConstrainedWithPrivate.#brand, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 13, 48)) + + value: T; +>value : Symbol(ConstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 14, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 13, 29)) + + copyValue(other: object) { +>copyValue : Symbol(ConstrainedWithPrivate.copyValue, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 15, 13)) +>other : Symbol(other, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 16, 14)) + + if (#brand in other) { +>#brand : Symbol(ConstrainedWithPrivate.#brand, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 13, 48)) +>other : Symbol(other, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 16, 14)) + + this.value = other.value; +>this.value : Symbol(ConstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 14, 11)) +>this : Symbol(ConstrainedWithPrivate, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 11, 1)) +>value : Symbol(ConstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 14, 11)) +>other.value : Symbol(ConstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 14, 11)) +>other : Symbol(other, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 16, 14)) +>value : Symbol(ConstrainedWithPrivate.value, Decl(strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts, 14, 11)) + } + } +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.types b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.types new file mode 100644 index 0000000000000..2841a10e7542b --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.types @@ -0,0 +1,71 @@ +=== tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts === +class UnconstrainedWithPrivate { +>UnconstrainedWithPrivate : UnconstrainedWithPrivate + + #brand; +>#brand : any + + value: T; +>value : T + + constructor(value: T) { +>value : T + + this.value = value; +>this.value = value : T +>this.value : T +>this : this +>value : T +>value : T + } + copyValue(other: object) { +>copyValue : (other: object) => void +>other : object + + if (#brand in other) { +>#brand in other : boolean +>#brand : any +>other : object + + this.value = other.value; +>this.value = other.value : unknown +>this.value : T +>this : this +>value : T +>other.value : unknown +>other : UnconstrainedWithPrivate +>value : unknown + } + } +} + +class ConstrainedWithPrivate { +>ConstrainedWithPrivate : ConstrainedWithPrivate + + #brand; +>#brand : any + + value: T; +>value : T + + copyValue(other: object) { +>copyValue : (other: object) => void +>other : object + + if (#brand in other) { +>#brand in other : boolean +>#brand : any +>other : object + + this.value = other.value; +>this.value = other.value : string +>this.value : T +>this : this +>value : T +>other.value : string +>other : ConstrainedWithPrivate +>value : string + } + } +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt new file mode 100644 index 0000000000000..c0818a156c43f --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt @@ -0,0 +1,173 @@ +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(9,9): error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant'. + Type 'unknown' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(11,9): error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant<"literal">'. + Type 'unknown' is not assignable to type '"literal"'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(21,9): error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant'. + Type 'string' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(24,9): error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant<"literal">'. + Type 'string' is not assignable to type '"literal"'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(34,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. + Type 'unknown' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(36,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. + Type 'any' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(37,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. + Type 'string' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(38,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant<"literal">'. + Type 'string' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(49,9): error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. + Type 'any' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(50,9): error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. + Type 'string' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(51,9): error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant<"literal">'. + Type 'string' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(62,9): error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant'. + The types returned by 'f(...)' are incompatible between these types. + Type 'unknown' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(64,9): error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant'. + The types returned by 'f(...)' are incompatible between these types. + Type 'unknown' is not assignable to type 'string'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(65,9): error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant<"literal">'. + The types returned by 'f(...)' are incompatible between these types. + Type 'unknown' is not assignable to type '"literal"'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(75,9): error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. + The types returned by 'f(...)' are incompatible between these types. + Type 'string' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(78,9): error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant<"literal">'. + The types returned by 'f(...)' are incompatible between these types. + Type 'string' is not assignable to type '"literal"'. + + +==== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts (16 errors) ==== + class UnconstrainedCovariant { + x: T; + } + + declare const unc_covariant: unknown; + + if (unc_covariant instanceof UnconstrainedCovariant) { + let unknown_covariant: UnconstrainedCovariant = unc_covariant; + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant'. +!!! error TS2322: Type 'unknown' is not assignable to type 'never'. + let any_covariant: UnconstrainedCovariant = unc_covariant; + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant<"literal">'. +!!! error TS2322: Type 'unknown' is not assignable to type '"literal"'. + } + + class ConstrainedCovariant { + x: T; + } + + declare const con_covariant: unknown; + + if (con_covariant instanceof ConstrainedCovariant) { + let never_covariant: ConstrainedCovariant = con_covariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let any_covariant: ConstrainedCovariant = con_covariant; + let constraint_covariant: ConstrainedCovariant = con_covariant; + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant<"literal">'. +!!! error TS2322: Type 'string' is not assignable to type '"literal"'. + } + + class UnconstrainedContravariant { + f: (x: T) => void; + } + + declare const unc_contravariant: unknown; + + if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error + ~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. +!!! error TS2322: Type 'unknown' is not assignable to type 'never'. + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. +!!! error TS2322: Type 'any' is not assignable to type 'never'. + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant<"literal">'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + } + + class ConstrainedContravariant { + f: (x: T) => void; + } + + declare const con_contravariant: unknown; + + if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. +!!! error TS2322: Type 'any' is not assignable to type 'never'. + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant<"literal">'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + } + + class UnconstrainedInvariant { + f: (x: T) => T; + } + + declare const unc_invariant: unknown; + + if (unc_invariant instanceof UnconstrainedInvariant) { + let unknown_covariant: UnconstrainedInvariant = unc_invariant; + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'unknown' is not assignable to type 'never'. + let any_covariant: UnconstrainedInvariant = unc_invariant; + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant<"literal">'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'unknown' is not assignable to type '"literal"'. + } + + class ConstrainedInvariant { + f: (x: T) => T; + } + + declare const con_invariant: unknown; + + if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant<"literal">'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"literal"'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js new file mode 100644 index 0000000000000..9e8db3107ec70 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js @@ -0,0 +1,151 @@ +//// [strictInstanceOfTypeParametersWithVarianceAnnotations.ts] +class UnconstrainedCovariant { + x: T; +} + +declare const unc_covariant: unknown; + +if (unc_covariant instanceof UnconstrainedCovariant) { + let unknown_covariant: UnconstrainedCovariant = unc_covariant; + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error + let any_covariant: UnconstrainedCovariant = unc_covariant; + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +} + +class ConstrainedCovariant { + x: T; +} + +declare const con_covariant: unknown; + +if (con_covariant instanceof ConstrainedCovariant) { + let never_covariant: ConstrainedCovariant = con_covariant; // Error + let any_covariant: ConstrainedCovariant = con_covariant; + let constraint_covariant: ConstrainedCovariant = con_covariant; + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +} + +class UnconstrainedContravariant { + f: (x: T) => void; +} + +declare const unc_contravariant: unknown; + +if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +} + +class ConstrainedContravariant { + f: (x: T) => void; +} + +declare const con_contravariant: unknown; + +if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +} + +class UnconstrainedInvariant { + f: (x: T) => T; +} + +declare const unc_invariant: unknown; + +if (unc_invariant instanceof UnconstrainedInvariant) { + let unknown_covariant: UnconstrainedInvariant = unc_invariant; + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error + let any_covariant: UnconstrainedInvariant = unc_invariant; + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +} + +class ConstrainedInvariant { + f: (x: T) => T; +} + +declare const con_invariant: unknown; + +if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +} + + +//// [strictInstanceOfTypeParametersWithVarianceAnnotations.js] +var UnconstrainedCovariant = /** @class */ (function () { + function UnconstrainedCovariant() { + } + return UnconstrainedCovariant; +}()); +if (unc_covariant instanceof UnconstrainedCovariant) { + var unknown_covariant = unc_covariant; + var never_covariant = unc_covariant; // Error + var any_covariant = unc_covariant; + var sub_covariant = unc_covariant; // Error +} +var ConstrainedCovariant = /** @class */ (function () { + function ConstrainedCovariant() { + } + return ConstrainedCovariant; +}()); +if (con_covariant instanceof ConstrainedCovariant) { + var never_covariant = con_covariant; // Error + var any_covariant = con_covariant; + var constraint_covariant = con_covariant; + var sub_covariant = con_covariant; // Error +} +var UnconstrainedContravariant = /** @class */ (function () { + function UnconstrainedContravariant() { + } + return UnconstrainedContravariant; +}()); +if (unc_contravariant instanceof UnconstrainedContravariant) { + var unknown_covariant = unc_contravariant; // Error + var never_covariant = unc_contravariant; + var any_covariant = unc_contravariant; // Error + var constraint_covariant = unc_contravariant; // Error + var sub_covariant = unc_contravariant; // Error +} +var ConstrainedContravariant = /** @class */ (function () { + function ConstrainedContravariant() { + } + return ConstrainedContravariant; +}()); +if (con_contravariant instanceof ConstrainedContravariant) { + var never_covariant = con_contravariant; + var any_covariant = con_contravariant; // Error + var constraint_covariant = con_contravariant; // Error + var sub_covariant = con_contravariant; // Error +} +var UnconstrainedInvariant = /** @class */ (function () { + function UnconstrainedInvariant() { + } + return UnconstrainedInvariant; +}()); +if (unc_invariant instanceof UnconstrainedInvariant) { + var unknown_covariant = unc_invariant; + var never_covariant = unc_invariant; // Error + var any_covariant = unc_invariant; + var constraint_covariant = unc_invariant; // Error + var sub_covariant = unc_invariant; // Error +} +var ConstrainedInvariant = /** @class */ (function () { + function ConstrainedInvariant() { + } + return ConstrainedInvariant; +}()); +if (con_invariant instanceof ConstrainedInvariant) { + var never_covariant = con_invariant; // Error + var any_covariant = con_invariant; + var constraint_covariant = con_invariant; + var sub_covariant = con_invariant; // Error +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols new file mode 100644 index 0000000000000..ffd9d703fd16a --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols @@ -0,0 +1,239 @@ +=== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts === +class UnconstrainedCovariant { +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) + + x: T; +>x : Symbol(UnconstrainedCovariant.x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 37)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) +} + +declare const unc_covariant: unknown; +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + +if (unc_covariant instanceof UnconstrainedCovariant) { +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) + + let unknown_covariant: UnconstrainedCovariant = unc_covariant; +>unknown_covariant : Symbol(unknown_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 7, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 8, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + + let any_covariant: UnconstrainedCovariant = unc_covariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 9, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 10, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +} + +class ConstrainedCovariant { +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 27)) + + x: T; +>x : Symbol(ConstrainedCovariant.x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 50)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 27)) +} + +declare const con_covariant: unknown; +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + +if (con_covariant instanceof ConstrainedCovariant) { +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) + + let never_covariant: ConstrainedCovariant = con_covariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 20, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + + let any_covariant: ConstrainedCovariant = con_covariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 21, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + + let constraint_covariant: ConstrainedCovariant = con_covariant; +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 23, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) +} + +class UnconstrainedContravariant { +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 33)) + + f: (x: T) => void; +>f : Symbol(UnconstrainedContravariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 40)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 27, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 33)) +} + +declare const unc_contravariant: unknown; +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + +if (unc_contravariant instanceof UnconstrainedContravariant) { +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) + + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>unknown_covariant : Symbol(unknown_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 33, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let never_covariant: UnconstrainedContravariant = unc_contravariant; +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 34, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 35, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 36, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 37, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) +} + +class ConstrainedContravariant { +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 31)) + + f: (x: T) => void; +>f : Symbol(ConstrainedContravariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 53)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 31)) +} + +declare const con_contravariant: unknown; +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + +if (con_contravariant instanceof ConstrainedContravariant) { +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) + + let never_covariant: ConstrainedContravariant = con_contravariant; +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 47, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + + let any_covariant: ConstrainedContravariant = con_contravariant; // Error +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 48, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 49, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 50, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) +} + +class UnconstrainedInvariant { +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 29)) + + f: (x: T) => T; +>f : Symbol(UnconstrainedInvariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 40)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 54, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 29)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 29)) +} + +declare const unc_invariant: unknown; +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + +if (unc_invariant instanceof UnconstrainedInvariant) { +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) + + let unknown_covariant: UnconstrainedInvariant = unc_invariant; +>unknown_covariant : Symbol(unknown_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 60, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 61, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let any_covariant: UnconstrainedInvariant = unc_invariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 62, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 63, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 64, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) +} + +class ConstrainedInvariant { +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) + + f: (x: T) => T; +>f : Symbol(ConstrainedInvariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 53)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 68, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) +} + +declare const con_invariant: unknown; +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + +if (con_invariant instanceof ConstrainedInvariant) { +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) + + let never_covariant: ConstrainedInvariant = con_invariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + + let any_covariant: ConstrainedInvariant = con_invariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + + let constraint_covariant: ConstrainedInvariant = con_invariant; +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 76, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 77, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types new file mode 100644 index 0000000000000..6a5041525e6e1 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types @@ -0,0 +1,205 @@ +=== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts === +class UnconstrainedCovariant { +>UnconstrainedCovariant : UnconstrainedCovariant + + x: T; +>x : T +} + +declare const unc_covariant: unknown; +>unc_covariant : unknown + +if (unc_covariant instanceof UnconstrainedCovariant) { +>unc_covariant instanceof UnconstrainedCovariant : boolean +>unc_covariant : unknown +>UnconstrainedCovariant : typeof UnconstrainedCovariant + + let unknown_covariant: UnconstrainedCovariant = unc_covariant; +>unknown_covariant : UnconstrainedCovariant +>unc_covariant : UnconstrainedCovariant + + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error +>never_covariant : UnconstrainedCovariant +>unc_covariant : UnconstrainedCovariant + + let any_covariant: UnconstrainedCovariant = unc_covariant; +>any_covariant : UnconstrainedCovariant +>unc_covariant : UnconstrainedCovariant + + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +>sub_covariant : UnconstrainedCovariant<"literal"> +>unc_covariant : UnconstrainedCovariant +} + +class ConstrainedCovariant { +>ConstrainedCovariant : ConstrainedCovariant + + x: T; +>x : T +} + +declare const con_covariant: unknown; +>con_covariant : unknown + +if (con_covariant instanceof ConstrainedCovariant) { +>con_covariant instanceof ConstrainedCovariant : boolean +>con_covariant : unknown +>ConstrainedCovariant : typeof ConstrainedCovariant + + let never_covariant: ConstrainedCovariant = con_covariant; // Error +>never_covariant : ConstrainedCovariant +>con_covariant : ConstrainedCovariant + + let any_covariant: ConstrainedCovariant = con_covariant; +>any_covariant : ConstrainedCovariant +>con_covariant : ConstrainedCovariant + + let constraint_covariant: ConstrainedCovariant = con_covariant; +>constraint_covariant : ConstrainedCovariant +>con_covariant : ConstrainedCovariant + + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +>sub_covariant : ConstrainedCovariant<"literal"> +>con_covariant : ConstrainedCovariant +} + +class UnconstrainedContravariant { +>UnconstrainedContravariant : UnconstrainedContravariant + + f: (x: T) => void; +>f : (x: T) => void +>x : T +} + +declare const unc_contravariant: unknown; +>unc_contravariant : unknown + +if (unc_contravariant instanceof UnconstrainedContravariant) { +>unc_contravariant instanceof UnconstrainedContravariant : boolean +>unc_contravariant : unknown +>UnconstrainedContravariant : typeof UnconstrainedContravariant + + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>unknown_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let never_covariant: UnconstrainedContravariant = unc_contravariant; +>never_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>any_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>constraint_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +>sub_covariant : UnconstrainedContravariant<"literal"> +>unc_contravariant : UnconstrainedContravariant +} + +class ConstrainedContravariant { +>ConstrainedContravariant : ConstrainedContravariant + + f: (x: T) => void; +>f : (x: T) => void +>x : T +} + +declare const con_contravariant: unknown; +>con_contravariant : unknown + +if (con_contravariant instanceof ConstrainedContravariant) { +>con_contravariant instanceof ConstrainedContravariant : boolean +>con_contravariant : unknown +>ConstrainedContravariant : typeof ConstrainedContravariant + + let never_covariant: ConstrainedContravariant = con_contravariant; +>never_covariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant + + let any_covariant: ConstrainedContravariant = con_contravariant; // Error +>any_covariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant + + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error +>constraint_covariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant + + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +>sub_covariant : ConstrainedContravariant<"literal"> +>con_contravariant : ConstrainedContravariant +} + +class UnconstrainedInvariant { +>UnconstrainedInvariant : UnconstrainedInvariant + + f: (x: T) => T; +>f : (x: T) => T +>x : T +} + +declare const unc_invariant: unknown; +>unc_invariant : unknown + +if (unc_invariant instanceof UnconstrainedInvariant) { +>unc_invariant instanceof UnconstrainedInvariant : boolean +>unc_invariant : unknown +>UnconstrainedInvariant : typeof UnconstrainedInvariant + + let unknown_covariant: UnconstrainedInvariant = unc_invariant; +>unknown_covariant : UnconstrainedInvariant +>unc_invariant : UnconstrainedInvariant + + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error +>never_covariant : UnconstrainedInvariant +>unc_invariant : UnconstrainedInvariant + + let any_covariant: UnconstrainedInvariant = unc_invariant; +>any_covariant : UnconstrainedInvariant +>unc_invariant : UnconstrainedInvariant + + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error +>constraint_covariant : UnconstrainedInvariant +>unc_invariant : UnconstrainedInvariant + + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +>sub_covariant : UnconstrainedInvariant<"literal"> +>unc_invariant : UnconstrainedInvariant +} + +class ConstrainedInvariant { +>ConstrainedInvariant : ConstrainedInvariant + + f: (x: T) => T; +>f : (x: T) => T +>x : T +} + +declare const con_invariant: unknown; +>con_invariant : unknown + +if (con_invariant instanceof ConstrainedInvariant) { +>con_invariant instanceof ConstrainedInvariant : boolean +>con_invariant : unknown +>ConstrainedInvariant : typeof ConstrainedInvariant + + let never_covariant: ConstrainedInvariant = con_invariant; // Error +>never_covariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant + + let any_covariant: ConstrainedInvariant = con_invariant; +>any_covariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant + + let constraint_covariant: ConstrainedInvariant = con_invariant; +>constraint_covariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant + + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +>sub_covariant : ConstrainedInvariant<"literal"> +>con_invariant : ConstrainedInvariant +} + diff --git a/tests/cases/compiler/strictInstanceOfTypeParameters.ts b/tests/cases/compiler/strictInstanceOfTypeParameters.ts new file mode 100644 index 0000000000000..3a5edc4db8a51 --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParameters.ts @@ -0,0 +1,38 @@ +// @strictInstanceOfTypeParameters: true + +class Unconstrained { + value: T; + read: (value: T) => void; +} + +declare const x: unknown; + +if (x instanceof Unconstrained) { + x.value.toUpperCase(); + x.value++; + x.value(); + + if (typeof x.value === "string") { + x.value.toUpperCase(); + } + if (typeof x.value === "number") { + x.value++; + } + + x.read(1); + x.read("foo"); +} + +class Constrained { + value: T; + read: (value: T) => void; +} + +declare const y: unknown; + +if (y instanceof Constrained) { + y.value++; + + y.read(1); + y.read("foo"); +} diff --git a/tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts b/tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts new file mode 100644 index 0000000000000..f874efd5d3db3 --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts @@ -0,0 +1,25 @@ +// @strictInstanceOfTypeParameters: true +// @target: es2015 + +class UnconstrainedWithPrivate { + #brand; + value: T; + constructor(value: T) { + this.value = value; + } + copyValue(other: object) { + if (#brand in other) { + this.value = other.value; + } + } +} + +class ConstrainedWithPrivate { + #brand; + value: T; + copyValue(other: object) { + if (#brand in other) { + this.value = other.value; + } + } +} diff --git a/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts new file mode 100644 index 0000000000000..ef3be13faa876 --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts @@ -0,0 +1,81 @@ +// @strictInstanceOfTypeParameters: true + +class UnconstrainedCovariant { + x: T; +} + +declare const unc_covariant: unknown; + +if (unc_covariant instanceof UnconstrainedCovariant) { + let unknown_covariant: UnconstrainedCovariant = unc_covariant; + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error + let any_covariant: UnconstrainedCovariant = unc_covariant; + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +} + +class ConstrainedCovariant { + x: T; +} + +declare const con_covariant: unknown; + +if (con_covariant instanceof ConstrainedCovariant) { + let never_covariant: ConstrainedCovariant = con_covariant; // Error + let any_covariant: ConstrainedCovariant = con_covariant; + let constraint_covariant: ConstrainedCovariant = con_covariant; + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +} + +class UnconstrainedContravariant { + f: (x: T) => void; +} + +declare const unc_contravariant: unknown; + +if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +} + +class ConstrainedContravariant { + f: (x: T) => void; +} + +declare const con_contravariant: unknown; + +if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +} + +class UnconstrainedInvariant { + f: (x: T) => T; +} + +declare const unc_invariant: unknown; + +if (unc_invariant instanceof UnconstrainedInvariant) { + let unknown_covariant: UnconstrainedInvariant = unc_invariant; + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error + let any_covariant: UnconstrainedInvariant = unc_invariant; + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +} + +class ConstrainedInvariant { + f: (x: T) => T; +} + +declare const con_invariant: unknown; + +if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +} diff --git a/tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpressions.ts b/tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpressions.ts index ce9d23aacc96d..6dac88d29d8c2 100644 --- a/tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpressions.ts +++ b/tests/cases/conformance/types/typeParameters/typeArgumentLists/instantiationExpressions.ts @@ -33,7 +33,7 @@ declare class C { } function f3() { - let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } + let c1 = C; // { new (x: string): C; f(x: U): T[]; prototype: C; } let f1 = C.f; // (x: string) => string[] }