From a3fcb95564303831eac657b8584ec6f7b73df60a Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Tue, 8 Nov 2022 14:15:03 -0500 Subject: [PATCH 1/7] New strict flag to narrow type parameters for instance checks --- src/compiler/checker.ts | 35 ++- src/compiler/commandLineParser.ts | 10 + src/compiler/diagnosticMessages.json | 5 +- src/compiler/types.ts | 1 + src/compiler/utilities.ts | 1 + .../reference/api/tsserverlibrary.d.ts | 1 + tests/baselines/reference/api/typescript.d.ts | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 1 + .../tsconfig.json | 5 + .../tsconfig.json | 5 + .../instantiationExpressions.errors.txt | 2 +- .../reference/instantiationExpressions.js | 4 +- .../instantiationExpressions.symbols | 2 +- .../reference/instantiationExpressions.types | 2 +- .../tsconfig.json | 5 + .../strictInstanceOfTypeParameters.errors.txt | 54 ++++ .../strictInstanceOfTypeParameters.js | 68 +++++ .../strictInstanceOfTypeParameters.symbols | 108 +++++++ .../strictInstanceOfTypeParameters.types | 126 ++++++++ ...rsFromPrivateNameInInExpression.errors.txt | 36 +++ ...ParametersFromPrivateNameInInExpression.js | 54 ++++ ...etersFromPrivateNameInInExpression.symbols | 71 +++++ ...ametersFromPrivateNameInInExpression.types | 71 +++++ ...rametersWithVarianceAnnotations.errors.txt | 119 ++++++++ ...OfTypeParametersWithVarianceAnnotations.js | 161 ++++++++++ ...eParametersWithVarianceAnnotations.symbols | 241 +++++++++++++++ ...ypeParametersWithVarianceAnnotations.types | 277 ++++++++++++++++++ .../strictInstanceOfTypeParameters.ts | 38 +++ ...ParametersFromPrivateNameInInExpression.ts | 25 ++ ...OfTypeParametersWithVarianceAnnotations.ts | 89 ++++++ .../instantiationExpressions.ts | 2 +- 41 files changed, 1618 insertions(+), 12 deletions(-) create mode 100644 tests/baselines/reference/config/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json create mode 100644 tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json create mode 100644 tests/baselines/reference/showConfig/Shows tsconfig for single option/inferInstanceTypeArgumentsAsConstraint/tsconfig.json create mode 100644 tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt create mode 100644 tests/baselines/reference/strictInstanceOfTypeParameters.js create mode 100644 tests/baselines/reference/strictInstanceOfTypeParameters.symbols create mode 100644 tests/baselines/reference/strictInstanceOfTypeParameters.types create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.js create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.symbols create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.types create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types create mode 100644 tests/cases/compiler/strictInstanceOfTypeParameters.ts create mode 100644 tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts create mode 100644 tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index beb75fd16d2dc..8f159642b4487 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1448,6 +1448,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny"); var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis"); var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); + var strictInstanceOfTypeParameters = getStrictOptionValue(compilerOptions, "strictInstanceOfTypeParameters"); var keyofStringsOnly = !!compilerOptions.keyofStringsOnly; var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : ObjectFlags.FreshLiteral; var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes; @@ -10136,13 +10137,37 @@ 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.Independent: + case VarianceFlags.Bivariant: + return anyType; + case VarianceFlags.Invariant: + return unknownType; + } + 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. // 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 +26976,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/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/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..f913aacb96d69 100644 --- a/tests/baselines/reference/instantiationExpressions.types +++ b/tests/baselines/reference/instantiationExpressions.types @@ -97,7 +97,7 @@ declare class C { function f3() { >f3 : () => void - 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 : { new (x: string): C; prototype: C; f(x: U): U[]; } >C : { new (x: string): C; prototype: C; f(x: U): U[]; } >C : typeof C 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..a2735af11bbbf --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt @@ -0,0 +1,119 @@ +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(20,13): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(30,14): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(31,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(32,8): error TS2349: This expression is not callable. + Type '{}' has no call signatures. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(60,14): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(61,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(62,8): error TS2349: This expression is not callable. + Type '{}' has no call signatures. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(83,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. + + +==== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts (8 errors) ==== + class UnconstrainedIn { + read: (value: T) => void; + } + + declare const x1: unknown; + + if (x1 instanceof UnconstrainedIn) { + x1.read(1); + x1.read("foo"); + } + + class ConstrainedIn { + read: (value: T) => void; + } + + declare const y1: unknown; + + if (y1 instanceof ConstrainedIn) { + y1.read(1); + y1.read("foo"); + ~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + } + + class UnconstrainedOut { + value: T; + } + + declare const x2: unknown; + + if (x2 instanceof UnconstrainedOut) { + x2.value.toUpperCase(); + ~~~~~~~~~~~ +!!! error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. + x2.value++; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. + x2.value(); + ~~~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type '{}' has no call signatures. + + if (typeof x2.value === "string") { + x2.value.toUpperCase(); + } + if (typeof x2.value === "number") { + x2.value++; + } + } + + class ConstrainedOut { + value: T; + } + + declare const y2: unknown; + + if (y2 instanceof ConstrainedOut) { + y2.value++; + } + + class UnconstrainedInOut { + value: T; + read: (value: T) => void; + } + + declare const x3: unknown; + + if (x3 instanceof UnconstrainedInOut) { + x3.value.toUpperCase(); + ~~~~~~~~~~~ +!!! error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. + x3.value++; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. + x3.value(); + ~~~~~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type '{}' has no call signatures. + + if (typeof x3.value === "string") { + x3.value.toUpperCase(); + } + if (typeof x3.value === "number") { + x3.value++; + } + + x3.read(1); + x3.read("foo"); + } + + class ConstrainedInOut { + value: T; + read: (value: T) => void; + } + + declare const y3: unknown; + + if (y3 instanceof ConstrainedInOut) { + y3.value++; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. + + y3.read(1); + y3.read("foo"); + } + \ 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..79e3d2924f1d5 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js @@ -0,0 +1,161 @@ +//// [strictInstanceOfTypeParametersWithVarianceAnnotations.ts] +class UnconstrainedIn { + read: (value: T) => void; +} + +declare const x1: unknown; + +if (x1 instanceof UnconstrainedIn) { + x1.read(1); + x1.read("foo"); +} + +class ConstrainedIn { + read: (value: T) => void; +} + +declare const y1: unknown; + +if (y1 instanceof ConstrainedIn) { + y1.read(1); + y1.read("foo"); +} + +class UnconstrainedOut { + value: T; +} + +declare const x2: unknown; + +if (x2 instanceof UnconstrainedOut) { + x2.value.toUpperCase(); + x2.value++; + x2.value(); + + if (typeof x2.value === "string") { + x2.value.toUpperCase(); + } + if (typeof x2.value === "number") { + x2.value++; + } +} + +class ConstrainedOut { + value: T; +} + +declare const y2: unknown; + +if (y2 instanceof ConstrainedOut) { + y2.value++; +} + +class UnconstrainedInOut { + value: T; + read: (value: T) => void; +} + +declare const x3: unknown; + +if (x3 instanceof UnconstrainedInOut) { + x3.value.toUpperCase(); + x3.value++; + x3.value(); + + if (typeof x3.value === "string") { + x3.value.toUpperCase(); + } + if (typeof x3.value === "number") { + x3.value++; + } + + x3.read(1); + x3.read("foo"); +} + +class ConstrainedInOut { + value: T; + read: (value: T) => void; +} + +declare const y3: unknown; + +if (y3 instanceof ConstrainedInOut) { + y3.value++; + + y3.read(1); + y3.read("foo"); +} + + +//// [strictInstanceOfTypeParametersWithVarianceAnnotations.js] +var UnconstrainedIn = /** @class */ (function () { + function UnconstrainedIn() { + } + return UnconstrainedIn; +}()); +if (x1 instanceof UnconstrainedIn) { + x1.read(1); + x1.read("foo"); +} +var ConstrainedIn = /** @class */ (function () { + function ConstrainedIn() { + } + return ConstrainedIn; +}()); +if (y1 instanceof ConstrainedIn) { + y1.read(1); + y1.read("foo"); +} +var UnconstrainedOut = /** @class */ (function () { + function UnconstrainedOut() { + } + return UnconstrainedOut; +}()); +if (x2 instanceof UnconstrainedOut) { + x2.value.toUpperCase(); + x2.value++; + x2.value(); + if (typeof x2.value === "string") { + x2.value.toUpperCase(); + } + if (typeof x2.value === "number") { + x2.value++; + } +} +var ConstrainedOut = /** @class */ (function () { + function ConstrainedOut() { + } + return ConstrainedOut; +}()); +if (y2 instanceof ConstrainedOut) { + y2.value++; +} +var UnconstrainedInOut = /** @class */ (function () { + function UnconstrainedInOut() { + } + return UnconstrainedInOut; +}()); +if (x3 instanceof UnconstrainedInOut) { + x3.value.toUpperCase(); + x3.value++; + x3.value(); + if (typeof x3.value === "string") { + x3.value.toUpperCase(); + } + if (typeof x3.value === "number") { + x3.value++; + } + x3.read(1); + x3.read("foo"); +} +var ConstrainedInOut = /** @class */ (function () { + function ConstrainedInOut() { + } + return ConstrainedInOut; +}()); +if (y3 instanceof ConstrainedInOut) { + y3.value++; + y3.read(1); + y3.read("foo"); +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols new file mode 100644 index 0000000000000..867bfb503018d --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols @@ -0,0 +1,241 @@ +=== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts === +class UnconstrainedIn { +>UnconstrainedIn : Symbol(UnconstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 22)) + + read: (value: T) => void; +>read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) +>value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 1, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 22)) +} + +declare const x1: unknown; +>x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + +if (x1 instanceof UnconstrainedIn) { +>x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +>UnconstrainedIn : Symbol(UnconstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) + + x1.read(1); +>x1.read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) +>x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +>read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) + + x1.read("foo"); +>x1.read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) +>x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +>read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) +} + +class ConstrainedIn { +>ConstrainedIn : Symbol(ConstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 9, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 20)) + + read: (value: T) => void; +>read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) +>value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 12, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 20)) +} + +declare const y1: unknown; +>y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) + +if (y1 instanceof ConstrainedIn) { +>y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) +>ConstrainedIn : Symbol(ConstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 9, 1)) + + y1.read(1); +>y1.read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) +>y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) +>read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) + + y1.read("foo"); +>y1.read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) +>y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) +>read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) +} + +class UnconstrainedOut { +>UnconstrainedOut : Symbol(UnconstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 20, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 23)) + + value: T; +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 23)) +} + +declare const x2: unknown; +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) + +if (x2 instanceof UnconstrainedOut) { +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>UnconstrainedOut : Symbol(UnconstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 20, 1)) + + x2.value.toUpperCase(); +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) + + x2.value++; +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) + + x2.value(); +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) + + if (typeof x2.value === "string") { +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) + + x2.value.toUpperCase(); +>x2.value.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + } + if (typeof x2.value === "number") { +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) + + x2.value++; +>x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) +>x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) +>value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) + } +} + +class ConstrainedOut { +>ConstrainedOut : Symbol(ConstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 39, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 21)) + + value: T; +>value : Symbol(ConstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 44)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 21)) +} + +declare const y2: unknown; +>y2 : Symbol(y2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 45, 13)) + +if (y2 instanceof ConstrainedOut) { +>y2 : Symbol(y2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 45, 13)) +>ConstrainedOut : Symbol(ConstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 39, 1)) + + y2.value++; +>y2.value : Symbol(ConstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 44)) +>y2 : Symbol(y2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 45, 13)) +>value : Symbol(ConstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 44)) +} + +class UnconstrainedInOut { +>UnconstrainedInOut : Symbol(UnconstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 49, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 25)) + + value: T; +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 25)) + + read: (value: T) => void; +>read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) +>value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 25)) +} + +declare const x3: unknown; +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) + +if (x3 instanceof UnconstrainedInOut) { +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>UnconstrainedInOut : Symbol(UnconstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 49, 1)) + + x3.value.toUpperCase(); +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) + + x3.value++; +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) + + x3.value(); +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) + + if (typeof x3.value === "string") { +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) + + x3.value.toUpperCase(); +>x3.value.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + } + if (typeof x3.value === "number") { +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) + + x3.value++; +>x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) + } + + x3.read(1); +>x3.read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) + + x3.read("foo"); +>x3.read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) +>x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) +>read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) +} + +class ConstrainedInOut { +>ConstrainedInOut : Symbol(ConstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 72, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 23)) + + value: T; +>value : Symbol(ConstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 49)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 23)) + + read: (value: T) => void; +>read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) +>value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 76, 11)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 23)) +} + +declare const y3: unknown; +>y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) + +if (y3 instanceof ConstrainedInOut) { +>y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) +>ConstrainedInOut : Symbol(ConstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 72, 1)) + + y3.value++; +>y3.value : Symbol(ConstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 49)) +>y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) +>value : Symbol(ConstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 49)) + + y3.read(1); +>y3.read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) +>y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) +>read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) + + y3.read("foo"); +>y3.read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) +>y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) +>read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types new file mode 100644 index 0000000000000..4e24f95bf4517 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types @@ -0,0 +1,277 @@ +=== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts === +class UnconstrainedIn { +>UnconstrainedIn : UnconstrainedIn + + read: (value: T) => void; +>read : (value: T) => void +>value : T +} + +declare const x1: unknown; +>x1 : unknown + +if (x1 instanceof UnconstrainedIn) { +>x1 instanceof UnconstrainedIn : boolean +>x1 : unknown +>UnconstrainedIn : typeof UnconstrainedIn + + x1.read(1); +>x1.read(1) : void +>x1.read : (value: unknown) => void +>x1 : UnconstrainedIn +>read : (value: unknown) => void +>1 : 1 + + x1.read("foo"); +>x1.read("foo") : void +>x1.read : (value: unknown) => void +>x1 : UnconstrainedIn +>read : (value: unknown) => void +>"foo" : "foo" +} + +class ConstrainedIn { +>ConstrainedIn : ConstrainedIn + + read: (value: T) => void; +>read : (value: T) => void +>value : T +} + +declare const y1: unknown; +>y1 : unknown + +if (y1 instanceof ConstrainedIn) { +>y1 instanceof ConstrainedIn : boolean +>y1 : unknown +>ConstrainedIn : typeof ConstrainedIn + + y1.read(1); +>y1.read(1) : void +>y1.read : (value: number) => void +>y1 : ConstrainedIn +>read : (value: number) => void +>1 : 1 + + y1.read("foo"); +>y1.read("foo") : void +>y1.read : (value: number) => void +>y1 : ConstrainedIn +>read : (value: number) => void +>"foo" : "foo" +} + +class UnconstrainedOut { +>UnconstrainedOut : UnconstrainedOut + + value: T; +>value : T +} + +declare const x2: unknown; +>x2 : unknown + +if (x2 instanceof UnconstrainedOut) { +>x2 instanceof UnconstrainedOut : boolean +>x2 : unknown +>UnconstrainedOut : typeof UnconstrainedOut + + x2.value.toUpperCase(); +>x2.value.toUpperCase() : any +>x2.value.toUpperCase : any +>x2.value : unknown +>x2 : UnconstrainedOut +>value : unknown +>toUpperCase : any + + x2.value++; +>x2.value++ : number +>x2.value : unknown +>x2 : UnconstrainedOut +>value : unknown + + x2.value(); +>x2.value() : any +>x2.value : unknown +>x2 : UnconstrainedOut +>value : unknown + + if (typeof x2.value === "string") { +>typeof x2.value === "string" : boolean +>typeof x2.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>x2.value : unknown +>x2 : UnconstrainedOut +>value : unknown +>"string" : "string" + + x2.value.toUpperCase(); +>x2.value.toUpperCase() : string +>x2.value.toUpperCase : () => string +>x2.value : string +>x2 : UnconstrainedOut +>value : string +>toUpperCase : () => string + } + if (typeof x2.value === "number") { +>typeof x2.value === "number" : boolean +>typeof x2.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>x2.value : unknown +>x2 : UnconstrainedOut +>value : unknown +>"number" : "number" + + x2.value++; +>x2.value++ : number +>x2.value : number +>x2 : UnconstrainedOut +>value : number + } +} + +class ConstrainedOut { +>ConstrainedOut : ConstrainedOut + + value: T; +>value : T +} + +declare const y2: unknown; +>y2 : unknown + +if (y2 instanceof ConstrainedOut) { +>y2 instanceof ConstrainedOut : boolean +>y2 : unknown +>ConstrainedOut : typeof ConstrainedOut + + y2.value++; +>y2.value++ : number +>y2.value : number +>y2 : ConstrainedOut +>value : number +} + +class UnconstrainedInOut { +>UnconstrainedInOut : UnconstrainedInOut + + value: T; +>value : T + + read: (value: T) => void; +>read : (value: T) => void +>value : T +} + +declare const x3: unknown; +>x3 : unknown + +if (x3 instanceof UnconstrainedInOut) { +>x3 instanceof UnconstrainedInOut : boolean +>x3 : unknown +>UnconstrainedInOut : typeof UnconstrainedInOut + + x3.value.toUpperCase(); +>x3.value.toUpperCase() : any +>x3.value.toUpperCase : any +>x3.value : unknown +>x3 : UnconstrainedInOut +>value : unknown +>toUpperCase : any + + x3.value++; +>x3.value++ : number +>x3.value : unknown +>x3 : UnconstrainedInOut +>value : unknown + + x3.value(); +>x3.value() : any +>x3.value : unknown +>x3 : UnconstrainedInOut +>value : unknown + + if (typeof x3.value === "string") { +>typeof x3.value === "string" : boolean +>typeof x3.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>x3.value : unknown +>x3 : UnconstrainedInOut +>value : unknown +>"string" : "string" + + x3.value.toUpperCase(); +>x3.value.toUpperCase() : string +>x3.value.toUpperCase : () => string +>x3.value : string +>x3 : UnconstrainedInOut +>value : string +>toUpperCase : () => string + } + if (typeof x3.value === "number") { +>typeof x3.value === "number" : boolean +>typeof x3.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>x3.value : unknown +>x3 : UnconstrainedInOut +>value : unknown +>"number" : "number" + + x3.value++; +>x3.value++ : number +>x3.value : number +>x3 : UnconstrainedInOut +>value : number + } + + x3.read(1); +>x3.read(1) : void +>x3.read : (value: unknown) => void +>x3 : UnconstrainedInOut +>read : (value: unknown) => void +>1 : 1 + + x3.read("foo"); +>x3.read("foo") : void +>x3.read : (value: unknown) => void +>x3 : UnconstrainedInOut +>read : (value: unknown) => void +>"foo" : "foo" +} + +class ConstrainedInOut { +>ConstrainedInOut : ConstrainedInOut + + value: T; +>value : T + + read: (value: T) => void; +>read : (value: T) => void +>value : T +} + +declare const y3: unknown; +>y3 : unknown + +if (y3 instanceof ConstrainedInOut) { +>y3 instanceof ConstrainedInOut : boolean +>y3 : unknown +>ConstrainedInOut : typeof ConstrainedInOut + + y3.value++; +>y3.value++ : number +>y3.value : unknown +>y3 : ConstrainedInOut +>value : unknown + + y3.read(1); +>y3.read(1) : void +>y3.read : (value: unknown) => void +>y3 : ConstrainedInOut +>read : (value: unknown) => void +>1 : 1 + + y3.read("foo"); +>y3.read("foo") : void +>y3.read : (value: unknown) => void +>y3 : ConstrainedInOut +>read : (value: unknown) => void +>"foo" : "foo" +} + 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..b6c6e6e05aae8 --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts @@ -0,0 +1,89 @@ +// @strictInstanceOfTypeParameters: true + +class UnconstrainedIn { + read: (value: T) => void; +} + +declare const x1: unknown; + +if (x1 instanceof UnconstrainedIn) { + x1.read(1); + x1.read("foo"); +} + +class ConstrainedIn { + read: (value: T) => void; +} + +declare const y1: unknown; + +if (y1 instanceof ConstrainedIn) { + y1.read(1); + y1.read("foo"); +} + +class UnconstrainedOut { + value: T; +} + +declare const x2: unknown; + +if (x2 instanceof UnconstrainedOut) { + x2.value.toUpperCase(); + x2.value++; + x2.value(); + + if (typeof x2.value === "string") { + x2.value.toUpperCase(); + } + if (typeof x2.value === "number") { + x2.value++; + } +} + +class ConstrainedOut { + value: T; +} + +declare const y2: unknown; + +if (y2 instanceof ConstrainedOut) { + y2.value++; +} + +class UnconstrainedInOut { + value: T; + read: (value: T) => void; +} + +declare const x3: unknown; + +if (x3 instanceof UnconstrainedInOut) { + x3.value.toUpperCase(); + x3.value++; + x3.value(); + + if (typeof x3.value === "string") { + x3.value.toUpperCase(); + } + if (typeof x3.value === "number") { + x3.value++; + } + + x3.read(1); + x3.read("foo"); +} + +class ConstrainedInOut { + value: T; + read: (value: T) => void; +} + +declare const y3: unknown; + +if (y3 instanceof ConstrainedInOut) { + y3.value++; + + y3.read(1); + y3.read("foo"); +} 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[] } From 95b3e5c2fff55293ef9bc3681245ba7446d05321 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Tue, 8 Nov 2022 21:20:35 -0500 Subject: [PATCH 2/7] Update inline comment to reflect new behavior --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8f159642b4487..492d7e7936ae0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10162,9 +10162,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } 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. + // 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 classSymbol = getParentOfSymbol(prototype)!; return getInstanceTypeOfClassSymbol(classSymbol); From f57d6088e4da62db5e0958b9aee94fac7ca597f9 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Mon, 30 Jan 2023 15:44:52 -0500 Subject: [PATCH 3/7] Update baseline with new behavior after rebase --- .../expressionWithJSDocTypeArguments.types | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) 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; From 5d4e7d7b6431a458d66b469c47e34f8d58baaf61 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Fri, 17 Mar 2023 10:59:40 -0400 Subject: [PATCH 4/7] Reformat variance test to match structure of existing variance test --- ...rametersWithVarianceAnnotations.errors.txt | 210 +++++---- ...OfTypeParametersWithVarianceAnnotations.js | 210 +++++---- ...eParametersWithVarianceAnnotations.symbols | 394 +++++++++-------- ...ypeParametersWithVarianceAnnotations.types | 414 ++++++++---------- ...OfTypeParametersWithVarianceAnnotations.ts | 108 +++-- 5 files changed, 635 insertions(+), 701 deletions(-) diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt index a2735af11bbbf..2abb477272027 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt @@ -1,119 +1,145 @@ -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(20,13): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(30,14): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(31,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(32,8): error TS2349: This expression is not callable. - Type '{}' has no call signatures. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(60,14): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(61,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(62,8): error TS2349: This expression is not callable. - Type '{}' has no call signatures. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(83,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. +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(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 'unknown' is not assignable to type 'never'. +tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(77,9): error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. + The types returned by 'f(...)' are incompatible between these types. + Type 'unknown' is not assignable to type 'string'. +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 'unknown' is not assignable to type '"literal"'. -==== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts (8 errors) ==== - class UnconstrainedIn { - read: (value: T) => void; +==== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts (10 errors) ==== + class UnconstrainedCovariant { + x: T; } - declare const x1: unknown; - - if (x1 instanceof UnconstrainedIn) { - x1.read(1); - x1.read("foo"); + 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 ConstrainedIn { - read: (value: T) => void; + class ConstrainedCovariant { + x: T; } - declare const y1: unknown; - - if (y1 instanceof ConstrainedIn) { - y1.read(1); - y1.read("foo"); - ~~~~~ -!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + 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 UnconstrainedOut { - value: T; + class UnconstrainedContravariant { + f: (x: T) => void; } - declare const x2: unknown; - - if (x2 instanceof UnconstrainedOut) { - x2.value.toUpperCase(); - ~~~~~~~~~~~ -!!! error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. - x2.value++; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. - x2.value(); - ~~~~~ -!!! error TS2349: This expression is not callable. -!!! error TS2349: Type '{}' has no call signatures. - - if (typeof x2.value === "string") { - x2.value.toUpperCase(); - } - if (typeof x2.value === "number") { - x2.value++; - } + declare const unc_contravariant: unknown; + + if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; } - class ConstrainedOut { - value: T; + class ConstrainedContravariant { + f: (x: T) => void; } - declare const y2: unknown; + declare const con_contravariant: unknown; - if (y2 instanceof ConstrainedOut) { - y2.value++; + if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; + let constraint_covariant: ConstrainedContravariant = con_contravariant; + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; } - class UnconstrainedInOut { - value: T; - read: (value: T) => void; + class UnconstrainedInvariant { + f: (x: T) => T; } - declare const x3: unknown; - - if (x3 instanceof UnconstrainedInOut) { - x3.value.toUpperCase(); - ~~~~~~~~~~~ -!!! error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. - x3.value++; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. - x3.value(); - ~~~~~ -!!! error TS2349: This expression is not callable. -!!! error TS2349: Type '{}' has no call signatures. - - if (typeof x3.value === "string") { - x3.value.toUpperCase(); - } - if (typeof x3.value === "number") { - x3.value++; - } - - x3.read(1); - x3.read("foo"); + 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 ConstrainedInOut { - value: T; - read: (value: T) => void; + class ConstrainedInvariant { + f: (x: T) => T; } - declare const y3: unknown; - - if (y3 instanceof ConstrainedInOut) { - y3.value++; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. - - y3.read(1); - y3.read("foo"); + 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 'unknown' is not assignable to type 'never'. + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_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 'unknown' is not assignable to type 'string'. + 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 'unknown' 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 index 79e3d2924f1d5..3921198dab2c1 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js @@ -1,161 +1,151 @@ //// [strictInstanceOfTypeParametersWithVarianceAnnotations.ts] -class UnconstrainedIn { - read: (value: T) => void; +class UnconstrainedCovariant { + x: T; } -declare const x1: unknown; +declare const unc_covariant: unknown; -if (x1 instanceof UnconstrainedIn) { - x1.read(1); - x1.read("foo"); +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 ConstrainedIn { - read: (value: T) => void; +class ConstrainedCovariant { + x: T; } -declare const y1: unknown; +declare const con_covariant: unknown; -if (y1 instanceof ConstrainedIn) { - y1.read(1); - y1.read("foo"); +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 UnconstrainedOut { - value: T; +class UnconstrainedContravariant { + f: (x: T) => void; } -declare const x2: unknown; +declare const unc_contravariant: unknown; -if (x2 instanceof UnconstrainedOut) { - x2.value.toUpperCase(); - x2.value++; - x2.value(); - - if (typeof x2.value === "string") { - x2.value.toUpperCase(); - } - if (typeof x2.value === "number") { - x2.value++; - } +if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; } -class ConstrainedOut { - value: T; +class ConstrainedContravariant { + f: (x: T) => void; } -declare const y2: unknown; +declare const con_contravariant: unknown; -if (y2 instanceof ConstrainedOut) { - y2.value++; +if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; + let constraint_covariant: ConstrainedContravariant = con_contravariant; + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; } -class UnconstrainedInOut { - value: T; - read: (value: T) => void; +class UnconstrainedInvariant { + f: (x: T) => T; } -declare const x3: unknown; - -if (x3 instanceof UnconstrainedInOut) { - x3.value.toUpperCase(); - x3.value++; - x3.value(); +declare const unc_invariant: unknown; - if (typeof x3.value === "string") { - x3.value.toUpperCase(); - } - if (typeof x3.value === "number") { - x3.value++; - } - - x3.read(1); - x3.read("foo"); +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 ConstrainedInOut { - value: T; - read: (value: T) => void; +class ConstrainedInvariant { + f: (x: T) => T; } -declare const y3: unknown; - -if (y3 instanceof ConstrainedInOut) { - y3.value++; +declare const con_invariant: unknown; - y3.read(1); - y3.read("foo"); +if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; // Error + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error } //// [strictInstanceOfTypeParametersWithVarianceAnnotations.js] -var UnconstrainedIn = /** @class */ (function () { - function UnconstrainedIn() { +var UnconstrainedCovariant = /** @class */ (function () { + function UnconstrainedCovariant() { } - return UnconstrainedIn; + return UnconstrainedCovariant; }()); -if (x1 instanceof UnconstrainedIn) { - x1.read(1); - x1.read("foo"); +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 ConstrainedIn = /** @class */ (function () { - function ConstrainedIn() { +var ConstrainedCovariant = /** @class */ (function () { + function ConstrainedCovariant() { } - return ConstrainedIn; + return ConstrainedCovariant; }()); -if (y1 instanceof ConstrainedIn) { - y1.read(1); - y1.read("foo"); +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 UnconstrainedOut = /** @class */ (function () { - function UnconstrainedOut() { +var UnconstrainedContravariant = /** @class */ (function () { + function UnconstrainedContravariant() { } - return UnconstrainedOut; + return UnconstrainedContravariant; }()); -if (x2 instanceof UnconstrainedOut) { - x2.value.toUpperCase(); - x2.value++; - x2.value(); - if (typeof x2.value === "string") { - x2.value.toUpperCase(); - } - if (typeof x2.value === "number") { - x2.value++; - } +if (unc_contravariant instanceof UnconstrainedContravariant) { + var unknown_covariant = unc_contravariant; + var never_covariant = unc_contravariant; + var any_covariant = unc_contravariant; + var constraint_covariant = unc_contravariant; + var sub_covariant = unc_contravariant; } -var ConstrainedOut = /** @class */ (function () { - function ConstrainedOut() { +var ConstrainedContravariant = /** @class */ (function () { + function ConstrainedContravariant() { } - return ConstrainedOut; + return ConstrainedContravariant; }()); -if (y2 instanceof ConstrainedOut) { - y2.value++; +if (con_contravariant instanceof ConstrainedContravariant) { + var never_covariant = con_contravariant; + var any_covariant = con_contravariant; + var constraint_covariant = con_contravariant; + var sub_covariant = con_contravariant; } -var UnconstrainedInOut = /** @class */ (function () { - function UnconstrainedInOut() { +var UnconstrainedInvariant = /** @class */ (function () { + function UnconstrainedInvariant() { } - return UnconstrainedInOut; + return UnconstrainedInvariant; }()); -if (x3 instanceof UnconstrainedInOut) { - x3.value.toUpperCase(); - x3.value++; - x3.value(); - if (typeof x3.value === "string") { - x3.value.toUpperCase(); - } - if (typeof x3.value === "number") { - x3.value++; - } - x3.read(1); - x3.read("foo"); +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 ConstrainedInOut = /** @class */ (function () { - function ConstrainedInOut() { +var ConstrainedInvariant = /** @class */ (function () { + function ConstrainedInvariant() { } - return ConstrainedInOut; + return ConstrainedInvariant; }()); -if (y3 instanceof ConstrainedInOut) { - y3.value++; - y3.read(1); - y3.read("foo"); +if (con_invariant instanceof ConstrainedInvariant) { + var never_covariant = con_invariant; // Error + var any_covariant = con_invariant; + var constraint_covariant = con_invariant; // Error + var sub_covariant = con_invariant; // Error } diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols index 867bfb503018d..b7e1d4b921cc4 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols @@ -1,241 +1,239 @@ === tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts === -class UnconstrainedIn { ->UnconstrainedIn : Symbol(UnconstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 22)) - - read: (value: T) => void; ->read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) ->value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 1, 11)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 22)) +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 x1: unknown; ->x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +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)) -if (x1 instanceof UnconstrainedIn) { ->x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) ->UnconstrainedIn : Symbol(UnconstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) + 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)) - x1.read(1); ->x1.read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) ->x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) ->read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) + 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)) - x1.read("foo"); ->x1.read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) ->x1 : Symbol(x1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) ->read : Symbol(UnconstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) + 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 ConstrainedIn { ->ConstrainedIn : Symbol(ConstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 9, 1)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 20)) +class ConstrainedCovariant { +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 27)) - read: (value: T) => void; ->read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) ->value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 12, 11)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 20)) + x: T; +>x : Symbol(ConstrainedCovariant.x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 50)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 27)) } -declare const y1: unknown; ->y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) +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)) -if (y1 instanceof ConstrainedIn) { ->y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) ->ConstrainedIn : Symbol(ConstrainedIn, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 9, 1)) + 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)) - y1.read(1); ->y1.read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) ->y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) ->read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) + 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)) - y1.read("foo"); ->y1.read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) ->y1 : Symbol(y1, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 15, 13)) ->read : Symbol(ConstrainedIn.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 42)) + 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 UnconstrainedOut { ->UnconstrainedOut : Symbol(UnconstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 20, 1)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 23)) +class UnconstrainedContravariant { +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 33)) - value: T; ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 23)) + 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 x2: unknown; ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) - -if (x2 instanceof UnconstrainedOut) { ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->UnconstrainedOut : Symbol(UnconstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 20, 1)) - - x2.value.toUpperCase(); ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) - - x2.value++; ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) - - x2.value(); ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) - - if (typeof x2.value === "string") { ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) - - x2.value.toUpperCase(); ->x2.value.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) - } - if (typeof x2.value === "number") { ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) - - x2.value++; ->x2.value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) ->x2 : Symbol(x2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 13)) ->value : Symbol(UnconstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 31)) - } +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; +>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; +>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; +>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; +>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 ConstrainedOut { ->ConstrainedOut : Symbol(ConstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 39, 1)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 21)) +class ConstrainedContravariant { +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 31)) - value: T; ->value : Symbol(ConstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 44)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 21)) + 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 y2: unknown; ->y2 : Symbol(y2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 45, 13)) +declare const con_contravariant: unknown; +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) -if (y2 instanceof ConstrainedOut) { ->y2 : Symbol(y2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 45, 13)) ->ConstrainedOut : Symbol(ConstrainedOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 39, 1)) +if (con_contravariant instanceof ConstrainedContravariant) { +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) - y2.value++; ->y2.value : Symbol(ConstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 44)) ->y2 : Symbol(y2, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 45, 13)) ->value : Symbol(ConstrainedOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 44)) -} + 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)) -class UnconstrainedInOut { ->UnconstrainedInOut : Symbol(UnconstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 49, 1)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 25)) + let any_covariant: ConstrainedContravariant = con_contravariant; +>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)) - value: T; ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 25)) + let constraint_covariant: ConstrainedContravariant = con_contravariant; +>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)) - read: (value: T) => void; ->read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) ->value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 11)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 25)) + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; +>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)) } -declare const x3: unknown; ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) - -if (x3 instanceof UnconstrainedInOut) { ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->UnconstrainedInOut : Symbol(UnconstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 49, 1)) - - x3.value.toUpperCase(); ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) - - x3.value++; ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) - - x3.value(); ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) - - if (typeof x3.value === "string") { ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) - - x3.value.toUpperCase(); ->x3.value.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) - } - if (typeof x3.value === "number") { ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) - - x3.value++; ->x3.value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->value : Symbol(UnconstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 36)) - } - - x3.read(1); ->x3.read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) - - x3.read("foo"); ->x3.read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 13)) ->x3 : Symbol(x3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 56, 13)) ->read : Symbol(UnconstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 52, 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)) } -class ConstrainedInOut { ->ConstrainedInOut : Symbol(ConstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 72, 1)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 23)) +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)) +} - value: T; ->value : Symbol(ConstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 49)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 23)) +class ConstrainedInvariant { +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) - read: (value: T) => void; ->read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) ->value : Symbol(value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 76, 11)) ->T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 23)) + 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 y3: unknown; ->y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) +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)) -if (y3 instanceof ConstrainedInOut) { ->y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) ->ConstrainedInOut : Symbol(ConstrainedInOut, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 72, 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)) - y3.value++; ->y3.value : Symbol(ConstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 49)) ->y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) ->value : Symbol(ConstrainedInOut.value, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 49)) + 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)) - y3.read(1); ->y3.read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) ->y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) ->read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) + let constraint_covariant: ConstrainedInvariant = con_invariant; // Error +>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)) - y3.read("foo"); ->y3.read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 13)) ->y3 : Symbol(y3, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 79, 13)) ->read : Symbol(ConstrainedInOut.read, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 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 index 4e24f95bf4517..ff375822686e5 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types @@ -1,277 +1,205 @@ === tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts === -class UnconstrainedIn { ->UnconstrainedIn : UnconstrainedIn +class UnconstrainedCovariant { +>UnconstrainedCovariant : UnconstrainedCovariant - read: (value: T) => void; ->read : (value: T) => void ->value : T + x: T; +>x : T } -declare const x1: unknown; ->x1 : unknown - -if (x1 instanceof UnconstrainedIn) { ->x1 instanceof UnconstrainedIn : boolean ->x1 : unknown ->UnconstrainedIn : typeof UnconstrainedIn - - x1.read(1); ->x1.read(1) : void ->x1.read : (value: unknown) => void ->x1 : UnconstrainedIn ->read : (value: unknown) => void ->1 : 1 - - x1.read("foo"); ->x1.read("foo") : void ->x1.read : (value: unknown) => void ->x1 : UnconstrainedIn ->read : (value: unknown) => void ->"foo" : "foo" +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 ConstrainedIn { ->ConstrainedIn : ConstrainedIn +class ConstrainedCovariant { +>ConstrainedCovariant : ConstrainedCovariant - read: (value: T) => void; ->read : (value: T) => void ->value : T + x: T; +>x : T } -declare const y1: unknown; ->y1 : unknown - -if (y1 instanceof ConstrainedIn) { ->y1 instanceof ConstrainedIn : boolean ->y1 : unknown ->ConstrainedIn : typeof ConstrainedIn - - y1.read(1); ->y1.read(1) : void ->y1.read : (value: number) => void ->y1 : ConstrainedIn ->read : (value: number) => void ->1 : 1 - - y1.read("foo"); ->y1.read("foo") : void ->y1.read : (value: number) => void ->y1 : ConstrainedIn ->read : (value: number) => void ->"foo" : "foo" +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 UnconstrainedOut { ->UnconstrainedOut : UnconstrainedOut +class UnconstrainedContravariant { +>UnconstrainedContravariant : UnconstrainedContravariant - value: T; ->value : T + f: (x: T) => void; +>f : (x: T) => void +>x : T } -declare const x2: unknown; ->x2 : unknown - -if (x2 instanceof UnconstrainedOut) { ->x2 instanceof UnconstrainedOut : boolean ->x2 : unknown ->UnconstrainedOut : typeof UnconstrainedOut - - x2.value.toUpperCase(); ->x2.value.toUpperCase() : any ->x2.value.toUpperCase : any ->x2.value : unknown ->x2 : UnconstrainedOut ->value : unknown ->toUpperCase : any - - x2.value++; ->x2.value++ : number ->x2.value : unknown ->x2 : UnconstrainedOut ->value : unknown - - x2.value(); ->x2.value() : any ->x2.value : unknown ->x2 : UnconstrainedOut ->value : unknown - - if (typeof x2.value === "string") { ->typeof x2.value === "string" : boolean ->typeof x2.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" ->x2.value : unknown ->x2 : UnconstrainedOut ->value : unknown ->"string" : "string" - - x2.value.toUpperCase(); ->x2.value.toUpperCase() : string ->x2.value.toUpperCase : () => string ->x2.value : string ->x2 : UnconstrainedOut ->value : string ->toUpperCase : () => string - } - if (typeof x2.value === "number") { ->typeof x2.value === "number" : boolean ->typeof x2.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" ->x2.value : unknown ->x2 : UnconstrainedOut ->value : unknown ->"number" : "number" - - x2.value++; ->x2.value++ : number ->x2.value : number ->x2 : UnconstrainedOut ->value : number - } +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; +>unknown_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let never_covariant: UnconstrainedContravariant = unc_contravariant; +>never_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let any_covariant: UnconstrainedContravariant = unc_contravariant; +>any_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; +>constraint_covariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant + + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; +>sub_covariant : UnconstrainedContravariant<"literal"> +>unc_contravariant : UnconstrainedContravariant } -class ConstrainedOut { ->ConstrainedOut : ConstrainedOut +class ConstrainedContravariant { +>ConstrainedContravariant : ConstrainedContravariant - value: T; ->value : T + f: (x: T) => void; +>f : (x: T) => void +>x : T } -declare const y2: unknown; ->y2 : unknown +declare const con_contravariant: unknown; +>con_contravariant : unknown -if (y2 instanceof ConstrainedOut) { ->y2 instanceof ConstrainedOut : boolean ->y2 : unknown ->ConstrainedOut : typeof ConstrainedOut +if (con_contravariant instanceof ConstrainedContravariant) { +>con_contravariant instanceof ConstrainedContravariant : boolean +>con_contravariant : unknown +>ConstrainedContravariant : typeof ConstrainedContravariant - y2.value++; ->y2.value++ : number ->y2.value : number ->y2 : ConstrainedOut ->value : number -} + let never_covariant: ConstrainedContravariant = con_contravariant; +>never_covariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant -class UnconstrainedInOut { ->UnconstrainedInOut : UnconstrainedInOut + let any_covariant: ConstrainedContravariant = con_contravariant; +>any_covariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant - value: T; ->value : T + let constraint_covariant: ConstrainedContravariant = con_contravariant; +>constraint_covariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant - read: (value: T) => void; ->read : (value: T) => void ->value : T + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; +>sub_covariant : ConstrainedContravariant<"literal"> +>con_contravariant : ConstrainedContravariant } -declare const x3: unknown; ->x3 : unknown - -if (x3 instanceof UnconstrainedInOut) { ->x3 instanceof UnconstrainedInOut : boolean ->x3 : unknown ->UnconstrainedInOut : typeof UnconstrainedInOut - - x3.value.toUpperCase(); ->x3.value.toUpperCase() : any ->x3.value.toUpperCase : any ->x3.value : unknown ->x3 : UnconstrainedInOut ->value : unknown ->toUpperCase : any - - x3.value++; ->x3.value++ : number ->x3.value : unknown ->x3 : UnconstrainedInOut ->value : unknown - - x3.value(); ->x3.value() : any ->x3.value : unknown ->x3 : UnconstrainedInOut ->value : unknown - - if (typeof x3.value === "string") { ->typeof x3.value === "string" : boolean ->typeof x3.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" ->x3.value : unknown ->x3 : UnconstrainedInOut ->value : unknown ->"string" : "string" - - x3.value.toUpperCase(); ->x3.value.toUpperCase() : string ->x3.value.toUpperCase : () => string ->x3.value : string ->x3 : UnconstrainedInOut ->value : string ->toUpperCase : () => string - } - if (typeof x3.value === "number") { ->typeof x3.value === "number" : boolean ->typeof x3.value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" ->x3.value : unknown ->x3 : UnconstrainedInOut ->value : unknown ->"number" : "number" - - x3.value++; ->x3.value++ : number ->x3.value : number ->x3 : UnconstrainedInOut ->value : number - } - - x3.read(1); ->x3.read(1) : void ->x3.read : (value: unknown) => void ->x3 : UnconstrainedInOut ->read : (value: unknown) => void ->1 : 1 - - x3.read("foo"); ->x3.read("foo") : void ->x3.read : (value: unknown) => void ->x3 : UnconstrainedInOut ->read : (value: unknown) => void ->"foo" : "foo" +class UnconstrainedInvariant { +>UnconstrainedInvariant : UnconstrainedInvariant + + f: (x: T) => T; +>f : (x: T) => T +>x : T } -class ConstrainedInOut { ->ConstrainedInOut : ConstrainedInOut +declare const unc_invariant: unknown; +>unc_invariant : unknown + +if (unc_invariant instanceof UnconstrainedInvariant) { +>unc_invariant instanceof UnconstrainedInvariant : boolean +>unc_invariant : unknown +>UnconstrainedInvariant : typeof UnconstrainedInvariant - value: T; ->value : T + let unknown_covariant: UnconstrainedInvariant = unc_invariant; +>unknown_covariant : UnconstrainedInvariant +>unc_invariant : UnconstrainedInvariant - read: (value: T) => void; ->read : (value: T) => void ->value : T + 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 } -declare const y3: unknown; ->y3 : unknown - -if (y3 instanceof ConstrainedInOut) { ->y3 instanceof ConstrainedInOut : boolean ->y3 : unknown ->ConstrainedInOut : typeof ConstrainedInOut - - y3.value++; ->y3.value++ : number ->y3.value : unknown ->y3 : ConstrainedInOut ->value : unknown - - y3.read(1); ->y3.read(1) : void ->y3.read : (value: unknown) => void ->y3 : ConstrainedInOut ->read : (value: unknown) => void ->1 : 1 - - y3.read("foo"); ->y3.read("foo") : void ->y3.read : (value: unknown) => void ->y3 : ConstrainedInOut ->read : (value: unknown) => void ->"foo" : "foo" +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; // Error +>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/strictInstanceOfTypeParametersWithVarianceAnnotations.ts b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts index b6c6e6e05aae8..e2f99ce208de5 100644 --- a/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts +++ b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts @@ -1,89 +1,81 @@ // @strictInstanceOfTypeParameters: true -class UnconstrainedIn { - read: (value: T) => void; +class UnconstrainedCovariant { + x: T; } -declare const x1: unknown; +declare const unc_covariant: unknown; -if (x1 instanceof UnconstrainedIn) { - x1.read(1); - x1.read("foo"); +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 ConstrainedIn { - read: (value: T) => void; +class ConstrainedCovariant { + x: T; } -declare const y1: unknown; +declare const con_covariant: unknown; -if (y1 instanceof ConstrainedIn) { - y1.read(1); - y1.read("foo"); +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 UnconstrainedOut { - value: T; +class UnconstrainedContravariant { + f: (x: T) => void; } -declare const x2: unknown; +declare const unc_contravariant: unknown; -if (x2 instanceof UnconstrainedOut) { - x2.value.toUpperCase(); - x2.value++; - x2.value(); - - if (typeof x2.value === "string") { - x2.value.toUpperCase(); - } - if (typeof x2.value === "number") { - x2.value++; - } +if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; } -class ConstrainedOut { - value: T; +class ConstrainedContravariant { + f: (x: T) => void; } -declare const y2: unknown; +declare const con_contravariant: unknown; -if (y2 instanceof ConstrainedOut) { - y2.value++; +if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; + let constraint_covariant: ConstrainedContravariant = con_contravariant; + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; } -class UnconstrainedInOut { - value: T; - read: (value: T) => void; +class UnconstrainedInvariant { + f: (x: T) => T; } -declare const x3: unknown; - -if (x3 instanceof UnconstrainedInOut) { - x3.value.toUpperCase(); - x3.value++; - x3.value(); +declare const unc_invariant: unknown; - if (typeof x3.value === "string") { - x3.value.toUpperCase(); - } - if (typeof x3.value === "number") { - x3.value++; - } - - x3.read(1); - x3.read("foo"); +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 ConstrainedInOut { - value: T; - read: (value: T) => void; +class ConstrainedInvariant { + f: (x: T) => T; } -declare const y3: unknown; - -if (y3 instanceof ConstrainedInOut) { - y3.value++; +declare const con_invariant: unknown; - y3.read(1); - y3.read("foo"); +if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; // Error + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error } From 061e41a45e512090ca545b2da8ca6dce62a10e38 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Fri, 17 Mar 2023 11:07:08 -0400 Subject: [PATCH 5/7] Default invariant type parameters to constraint, contravariant to never --- src/compiler/checker.ts | 4 +- ...rametersWithVarianceAnnotations.errors.txt | 76 +++++++++++++------ ...OfTypeParametersWithVarianceAnnotations.js | 32 ++++---- ...eParametersWithVarianceAnnotations.symbols | 16 ++-- ...ypeParametersWithVarianceAnnotations.types | 42 +++++----- ...OfTypeParametersWithVarianceAnnotations.ts | 16 ++-- 6 files changed, 107 insertions(+), 79 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 492d7e7936ae0..d75f0cfda5317 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10153,8 +10153,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { case VarianceFlags.Independent: case VarianceFlags.Bivariant: return anyType; - case VarianceFlags.Invariant: - return unknownType; + case VarianceFlags.Contravariant: + return neverType; } return getBaseConstraintOfType(typeParameter) || unknownType; }); diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt index 2abb477272027..c0818a156c43f 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt @@ -6,6 +6,20 @@ tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(21 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'. @@ -15,18 +29,15 @@ tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(64 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'. +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 'unknown' is not assignable to type 'never'. -tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(77,9): error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. + 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 'unknown' is not assignable to type 'string'. -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 'unknown' is not assignable to type '"literal"'. + Type 'string' is not assignable to type '"literal"'. -==== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts (10 errors) ==== +==== tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts (16 errors) ==== class UnconstrainedCovariant { x: T; } @@ -72,11 +83,23 @@ tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(78 declare const unc_contravariant: unknown; if (unc_contravariant instanceof UnconstrainedContravariant) { - let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + 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; - let constraint_covariant: UnconstrainedContravariant = unc_contravariant; - let sub_covariant: UnconstrainedContravariant<"literal"> = 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 { @@ -87,9 +110,18 @@ tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(78 if (con_contravariant instanceof ConstrainedContravariant) { let never_covariant: ConstrainedContravariant = con_contravariant; - let any_covariant: ConstrainedContravariant = con_contravariant; - let constraint_covariant: ConstrainedContravariant = con_contravariant; - let sub_covariant: ConstrainedContravariant<"literal"> = 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 { @@ -127,19 +159,15 @@ tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts(78 if (con_invariant instanceof ConstrainedInvariant) { let never_covariant: ConstrainedInvariant = con_invariant; // Error ~~~~~~~~~~~~~~~ -!!! error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. +!!! 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 'unknown' is not assignable to type 'never'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. let any_covariant: ConstrainedInvariant = con_invariant; - let constraint_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 'unknown' is not assignable to type 'string'. + 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: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant<"literal">'. !!! error TS2322: The types returned by 'f(...)' are incompatible between these types. -!!! error TS2322: Type 'unknown' is not assignable to type '"literal"'. +!!! 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 index 3921198dab2c1..9e8db3107ec70 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js @@ -32,11 +32,11 @@ class UnconstrainedContravariant { declare const unc_contravariant: unknown; if (unc_contravariant instanceof UnconstrainedContravariant) { - let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error let never_covariant: UnconstrainedContravariant = unc_contravariant; - let any_covariant: UnconstrainedContravariant = unc_contravariant; - let constraint_covariant: UnconstrainedContravariant = unc_contravariant; - let sub_covariant: UnconstrainedContravariant<"literal"> = 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 { @@ -47,9 +47,9 @@ declare const con_contravariant: unknown; if (con_contravariant instanceof ConstrainedContravariant) { let never_covariant: ConstrainedContravariant = con_contravariant; - let any_covariant: ConstrainedContravariant = con_contravariant; - let constraint_covariant: ConstrainedContravariant = con_contravariant; - let sub_covariant: ConstrainedContravariant<"literal"> = 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 { @@ -75,7 +75,7 @@ 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; // Error + let constraint_covariant: ConstrainedInvariant = con_invariant; let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error } @@ -109,11 +109,11 @@ var UnconstrainedContravariant = /** @class */ (function () { return UnconstrainedContravariant; }()); if (unc_contravariant instanceof UnconstrainedContravariant) { - var unknown_covariant = unc_contravariant; + var unknown_covariant = unc_contravariant; // Error var never_covariant = unc_contravariant; - var any_covariant = unc_contravariant; - var constraint_covariant = unc_contravariant; - var sub_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() { @@ -122,9 +122,9 @@ var ConstrainedContravariant = /** @class */ (function () { }()); if (con_contravariant instanceof ConstrainedContravariant) { var never_covariant = con_contravariant; - var any_covariant = con_contravariant; - var constraint_covariant = con_contravariant; - var sub_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() { @@ -146,6 +146,6 @@ var ConstrainedInvariant = /** @class */ (function () { if (con_invariant instanceof ConstrainedInvariant) { var never_covariant = con_invariant; // Error var any_covariant = con_invariant; - var constraint_covariant = con_invariant; // Error + 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 index b7e1d4b921cc4..ffd9d703fd16a 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols @@ -90,7 +90,7 @@ 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; + 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)) @@ -100,17 +100,17 @@ if (unc_contravariant instanceof UnconstrainedContravariant) { >UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) >unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) - let any_covariant: UnconstrainedContravariant = unc_contravariant; + 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; + 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; + 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)) @@ -138,17 +138,17 @@ if (con_contravariant instanceof ConstrainedContravariant) { >ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) >con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) - let any_covariant: ConstrainedContravariant = con_contravariant; + 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; + 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; + 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)) @@ -226,7 +226,7 @@ if (con_invariant instanceof ConstrainedInvariant) { >ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) >con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) - let constraint_covariant: ConstrainedInvariant = con_invariant; // Error + 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)) diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types index ff375822686e5..6a5041525e6e1 100644 --- a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types @@ -79,25 +79,25 @@ if (unc_contravariant instanceof UnconstrainedContravariant) { >unc_contravariant : unknown >UnconstrainedContravariant : typeof UnconstrainedContravariant - let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error >unknown_covariant : UnconstrainedContravariant ->unc_contravariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant let never_covariant: UnconstrainedContravariant = unc_contravariant; >never_covariant : UnconstrainedContravariant ->unc_contravariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant - let any_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error >any_covariant : UnconstrainedContravariant ->unc_contravariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant - let constraint_covariant: UnconstrainedContravariant = unc_contravariant; + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error >constraint_covariant : UnconstrainedContravariant ->unc_contravariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant - let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error >sub_covariant : UnconstrainedContravariant<"literal"> ->unc_contravariant : UnconstrainedContravariant +>unc_contravariant : UnconstrainedContravariant } class ConstrainedContravariant { @@ -118,19 +118,19 @@ if (con_contravariant instanceof ConstrainedContravariant) { let never_covariant: ConstrainedContravariant = con_contravariant; >never_covariant : ConstrainedContravariant ->con_contravariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant - let any_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error >any_covariant : ConstrainedContravariant ->con_contravariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant - let constraint_covariant: ConstrainedContravariant = con_contravariant; + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error >constraint_covariant : ConstrainedContravariant ->con_contravariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant - let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error >sub_covariant : ConstrainedContravariant<"literal"> ->con_contravariant : ConstrainedContravariant +>con_contravariant : ConstrainedContravariant } class UnconstrainedInvariant { @@ -188,18 +188,18 @@ if (con_invariant instanceof ConstrainedInvariant) { let never_covariant: ConstrainedInvariant = con_invariant; // Error >never_covariant : ConstrainedInvariant ->con_invariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant let any_covariant: ConstrainedInvariant = con_invariant; >any_covariant : ConstrainedInvariant ->con_invariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant - let constraint_covariant: ConstrainedInvariant = con_invariant; // Error + let constraint_covariant: ConstrainedInvariant = con_invariant; >constraint_covariant : ConstrainedInvariant ->con_invariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error >sub_covariant : ConstrainedInvariant<"literal"> ->con_invariant : ConstrainedInvariant +>con_invariant : ConstrainedInvariant } diff --git a/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts index e2f99ce208de5..ef3be13faa876 100644 --- a/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts +++ b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts @@ -33,11 +33,11 @@ class UnconstrainedContravariant { declare const unc_contravariant: unknown; if (unc_contravariant instanceof UnconstrainedContravariant) { - let unknown_covariant: UnconstrainedContravariant = unc_contravariant; + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error let never_covariant: UnconstrainedContravariant = unc_contravariant; - let any_covariant: UnconstrainedContravariant = unc_contravariant; - let constraint_covariant: UnconstrainedContravariant = unc_contravariant; - let sub_covariant: UnconstrainedContravariant<"literal"> = 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 { @@ -48,9 +48,9 @@ declare const con_contravariant: unknown; if (con_contravariant instanceof ConstrainedContravariant) { let never_covariant: ConstrainedContravariant = con_contravariant; - let any_covariant: ConstrainedContravariant = con_contravariant; - let constraint_covariant: ConstrainedContravariant = con_contravariant; - let sub_covariant: ConstrainedContravariant<"literal"> = 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 { @@ -76,6 +76,6 @@ 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; // Error + let constraint_covariant: ConstrainedInvariant = con_invariant; let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error } From e4235a7ce7cc0b67b8fabcdaf0810f5e854ff5d8 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Fri, 17 Mar 2023 15:45:44 -0400 Subject: [PATCH 6/7] Contravariant and bivariant default to never, else use constraint --- src/compiler/checker.ts | 4 +--- .../baselines/reference/accessorsOverrideProperty9.types | 2 +- tests/baselines/reference/instantiationExpressions.types | 4 ++-- .../reference/overrideBaseIntersectionMethod.types | 8 ++++---- 4 files changed, 8 insertions(+), 10 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d75f0cfda5317..00f65ce888186 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10150,10 +10150,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } const variance = variances[i]; switch (variance & VarianceFlags.VarianceMask) { - case VarianceFlags.Independent: - case VarianceFlags.Bivariant: - return anyType; case VarianceFlags.Contravariant: + case VarianceFlags.Bivariant: return neverType; } return getBaseConstraintOfType(typeParameter) || unknownType; 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/instantiationExpressions.types b/tests/baselines/reference/instantiationExpressions.types index f913aacb96d69..5da8dd2880568 100644 --- a/tests/baselines/reference/instantiationExpressions.types +++ b/tests/baselines/reference/instantiationExpressions.types @@ -98,8 +98,8 @@ 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[]; } +>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() { From 0106a184f3bb50b2839d53780c74387c49853c00 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Tue, 21 Mar 2023 18:11:32 -0400 Subject: [PATCH 7/7] Set flag true by default, for testing purposes --- src/compiler/checker.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 00f65ce888186..01732be6ed2fb 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1448,7 +1448,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny"); var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis"); var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); - var strictInstanceOfTypeParameters = getStrictOptionValue(compilerOptions, "strictInstanceOfTypeParameters"); + // 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;