From e538a5b567cd00412e5f249151e199065ed9393b Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Mon, 1 Apr 2024 16:54:32 -0400 Subject: [PATCH 1/3] New compiler option to infer type arguments on instance check --- src/compiler/checker.ts | 65 +++++++++++++++++++++++++--- src/compiler/commandLineParser.ts | 10 +++++ src/compiler/diagnosticMessages.json | 4 ++ src/compiler/types.ts | 1 + src/compiler/utilities.ts | 9 +++- 5 files changed, 82 insertions(+), 7 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 027007fb15b62..ea714401fca1b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1484,6 +1484,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 exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes; var checkBinaryExpression = createCheckBinaryExpression(); @@ -10534,13 +10535,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 isJs = some(classSymbol.declarations, isInJSFile); + const inferredTypes = calculateInferredTypeArguments(classType.typeParameters, isJs); + const typeArguments = map(inferredTypes, (inferredType, i) => { + if (!strictInstanceOfTypeParameters) { + return anyType; + } + const variance = variances[i]; + switch (variance & VarianceFlags.VarianceMask) { + case VarianceFlags.Contravariant: + case VarianceFlags.Bivariant: + return neverType; + } + return inferredType || unknownType; + }); + return createTypeReference(classType, typeArguments); + } + function getTypeOfPrototypeProperty(prototype: Symbol): Type { - // TypeScript 1.0 spec (April 2014): 8.4 // Every class automatically contains a static property member named 'prototype', - // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter. + // the type of which is an instantiation of the class type. + // Type parameters on this class are instantiated with a type based on their constraint and variance. // It is an error to explicitly declare a static property member with the name 'prototype'. - const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype)!) as InterfaceType; - return classType.typeParameters ? createTypeReference(classType as GenericType, map(classType.typeParameters, _ => anyType)) : classType; + const classSymbol = getParentOfSymbol(prototype)!; + return getInstanceTypeOfClassSymbol(classSymbol); } // Return the type of the given property in the given type, or undefined if no such property exists @@ -15061,6 +15086,34 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return typeArguments && typeArguments.slice(); } + /** + * Similar to `fillMissingTypeArguments` returns an array of type arguments that correspond to + * the input array of type parameters. + * However, this function infers the type of each argument to be the constraint of the type + * parameter; instantiating them with the other inferred type arguments. + */ + function calculateInferredTypeArguments(typeParameters: readonly TypeParameter[] | undefined, isJavaScriptImplicitAny: boolean) { + const numTypeParameters = length(typeParameters); + if (!numTypeParameters) { + return []; + } + const result = []; + // Map invalid forward references in default types to the error type + for (let i = 0; i < numTypeParameters; i++) { + result[i] = errorType; + } + const baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny); + for (let i = 0; i < numTypeParameters; i++) { + let inferredType = getBaseConstraintOfType(typeParameters![i]); + if (isJavaScriptImplicitAny && inferredType && (isTypeIdenticalTo(inferredType, unknownType) || isTypeIdenticalTo(inferredType, emptyObjectType))) { + inferredType = anyType; + } + result[i] = inferredType ? instantiateType(inferredType, createTypeMapper(typeParameters!, result)) : baseDefaultType; + } + result.length = typeParameters!.length; + return result; + } + function getSignatureFromDeclaration(declaration: SignatureDeclaration | JSDocSignature): Signature { const links = getNodeLinks(declaration); if (!links.resolvedSignature) { @@ -28411,10 +28464,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 9e103d0a90dce..54965b403e16c 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -919,6 +919,16 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [ description: Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor, defaultValueDescription: Diagnostics.false_unless_strict_is_set, }, + { + name: "strictInstanceOfTypeParameters", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsBuildInfo: true, + strictFlag: true, + category: Diagnostics.Type_Checking, + description: Diagnostics.Default_type_arguments_to_parameter_s_constraint_or_unknown_instead_of_any_for_instance_checks, + defaultValueDescription: false, + }, { name: "noImplicitThis", type: "boolean", diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 1db3b8c70bc30..fce6e4a4be6f5 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -6392,6 +6392,10 @@ "category": "Message", "code": 6805 }, + "Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks.": { + "category": "Message", + "code": 6806 + }, "one of:": { "category": "Message", diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 21339a7742bd9..b7ac8bea2d2a9 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -7351,6 +7351,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; // Always combine with strict property stripInternal?: boolean; /** @deprecated */ suppressExcessPropertyErrors?: boolean; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index b22ba836761e2..9e6c6aab39a66 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -9016,6 +9016,12 @@ export const computedOptions = createComputedCompilerOptions({ return getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); }, }, + strictInstanceOfTypeParameters: { + dependencies: ["strict"], + computeValue: compilerOptions => { + return getStrictOptionValue(compilerOptions, "strictInstanceOfTypeParameters"); + }, + }, }); /** @internal */ @@ -9092,7 +9098,8 @@ export type StrictOptionName = | "strictBindCallApply" | "strictPropertyInitialization" | "alwaysStrict" - | "useUnknownInCatchVariables"; + | "useUnknownInCatchVariables" + | "strictInstanceOfTypeParameters"; /** @internal */ export function getStrictOptionValue(compilerOptions: CompilerOptions, flag: StrictOptionName): boolean { From 98ddbcccc8a15a9f3b2b4e8943b10d5d292c0b6a Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Mon, 1 Apr 2024 16:54:54 -0400 Subject: [PATCH 2/3] Test cases for new proposed feature --- .../strictInstanceOfTypeParameters.ts | 38 +++++++++ ...tanceOfTypeParametersFromAnonymousClass.ts | 18 +++++ ...ParametersFromPrivateNameInInExpression.ts | 25 ++++++ ...OfTypeParametersWithLocalTypeReferences.ts | 14 ++++ ...OfTypeParametersWithVarianceAnnotations.ts | 81 +++++++++++++++++++ 5 files changed, 176 insertions(+) create mode 100644 tests/cases/compiler/strictInstanceOfTypeParameters.ts create mode 100644 tests/cases/compiler/strictInstanceOfTypeParametersFromAnonymousClass.ts create mode 100644 tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts create mode 100644 tests/cases/compiler/strictInstanceOfTypeParametersWithLocalTypeReferences.ts create mode 100644 tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts diff --git a/tests/cases/compiler/strictInstanceOfTypeParameters.ts b/tests/cases/compiler/strictInstanceOfTypeParameters.ts new file mode 100644 index 0000000000000..d6c6a6beb8c09 --- /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/strictInstanceOfTypeParametersFromAnonymousClass.ts b/tests/cases/compiler/strictInstanceOfTypeParametersFromAnonymousClass.ts new file mode 100644 index 0000000000000..788a9f09af0b9 --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParametersFromAnonymousClass.ts @@ -0,0 +1,18 @@ +// @strictInstanceOfTypeParameters: true + +function MakeClass(someStuff: T) { + return class { + someStuff = someStuff; + }; +} + +const MadeClassNumber = MakeClass(123); +const MadeClassString = MakeClass("foo"); + +const numberInstance = new MadeClassNumber(); +numberInstance.someStuff; + +declare const someInstance: unknown; +if (someInstance instanceof MadeClassNumber) { + someInstance.someStuff; +} diff --git a/tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts b/tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts new file mode 100644 index 0000000000000..ab33dc9734465 --- /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/strictInstanceOfTypeParametersWithLocalTypeReferences.ts b/tests/cases/compiler/strictInstanceOfTypeParametersWithLocalTypeReferences.ts new file mode 100644 index 0000000000000..c0a1c97dcc7aa --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParametersWithLocalTypeReferences.ts @@ -0,0 +1,14 @@ +// @strictInstanceOfTypeParameters: true + +class Box { + value: T; +} + +class BoxBox> { + box: B; +} + +declare const bb: any; +if (bb instanceof BoxBox) { + bb.box.value; +} diff --git a/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts new file mode 100644 index 0000000000000..99469b2ae8ce5 --- /dev/null +++ b/tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts @@ -0,0 +1,81 @@ +// @strictInstanceOfTypeParameters: true + +class UnconstrainedCovariant { + x: T; +} + +declare const unc_covariant: unknown; + +if (unc_covariant instanceof UnconstrainedCovariant) { + let unknown_covariant: UnconstrainedCovariant = unc_covariant; + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error + let any_covariant: UnconstrainedCovariant = unc_covariant; + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +} + +class ConstrainedCovariant { + x: T; +} + +declare const con_covariant: unknown; + +if (con_covariant instanceof ConstrainedCovariant) { + let never_covariant: ConstrainedCovariant = con_covariant; // Error + let any_covariant: ConstrainedCovariant = con_covariant; + let constraint_covariant: ConstrainedCovariant = con_covariant; + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +} + +class UnconstrainedContravariant { + f: (x: T) => void; +} + +declare const unc_contravariant: unknown; + +if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +} + +class ConstrainedContravariant { + f: (x: T) => void; +} + +declare const con_contravariant: unknown; + +if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +} + +class UnconstrainedInvariant { + f: (x: T) => T; +} + +declare const unc_invariant: unknown; + +if (unc_invariant instanceof UnconstrainedInvariant) { + let unknown_covariant: UnconstrainedInvariant = unc_invariant; + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error + let any_covariant: UnconstrainedInvariant = unc_invariant; + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +} + +class ConstrainedInvariant { + f: (x: T) => T; +} + +declare const con_invariant: unknown; + +if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +} From 26df4e964d50151bdf4032c2cecc5efcf5a14c01 Mon Sep 17 00:00:00 2001 From: Michael Molisani Date: Mon, 1 Apr 2024 16:55:31 -0400 Subject: [PATCH 3/3] Baseline update for checker changes and new tests --- .../accessorsOverrideProperty9.types | 4 +- ...sionGenericIntersectionNoCrash1.errors.txt | 8 +- ...xpressionGenericIntersectionNoCrash1.types | 16 +- ...sionGenericIntersectionNoCrash2.errors.txt | 4 +- 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 | 3 +- .../strict/tsconfig.json | 3 +- .../tsconfig.json | 5 + .../expressionWithJSDocTypeArguments.types | 32 +- .../reference/instantiationExpressions.types | 8 +- .../overrideBaseIntersectionMethod.types | 16 +- .../strictInstanceOfTypeParameters.errors.txt | 54 ++++ .../strictInstanceOfTypeParameters.js | 70 ++++ .../strictInstanceOfTypeParameters.symbols | 110 +++++++ .../strictInstanceOfTypeParameters.types | 204 ++++++++++++ ...tanceOfTypeParametersFromAnonymousClass.js | 37 +++ ...OfTypeParametersFromAnonymousClass.symbols | 47 +++ ...ceOfTypeParametersFromAnonymousClass.types | 79 +++++ ...rsFromPrivateNameInInExpression.errors.txt | 36 +++ ...ParametersFromPrivateNameInInExpression.js | 56 ++++ ...etersFromPrivateNameInInExpression.symbols | 73 +++++ ...ametersFromPrivateNameInInExpression.types | 109 +++++++ ...OfTypeParametersWithLocalTypeReferences.js | 31 ++ ...eParametersWithLocalTypeReferences.symbols | 39 +++ ...ypeParametersWithLocalTypeReferences.types | 44 +++ ...rametersWithVarianceAnnotations.errors.txt | 173 ++++++++++ ...OfTypeParametersWithVarianceAnnotations.js | 153 +++++++++ ...eParametersWithVarianceAnnotations.symbols | 241 ++++++++++++++ ...ypeParametersWithVarianceAnnotations.types | 299 ++++++++++++++++++ 40 files changed, 1920 insertions(+), 46 deletions(-) create mode 100644 tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/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/strictInstanceOfTypeParametersFromAnonymousClass.js create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.symbols create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.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/strictInstanceOfTypeParametersWithLocalTypeReferences.js create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.symbols create mode 100644 tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.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 diff --git a/tests/baselines/reference/accessorsOverrideProperty9.types b/tests/baselines/reference/accessorsOverrideProperty9.types index 9f4156dfb087f..fb8481c23b96f 100644 --- a/tests/baselines/reference/accessorsOverrideProperty9.types +++ b/tests/baselines/reference/accessorsOverrideProperty9.types @@ -91,8 +91,8 @@ 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/aliasInstantiationExpressionGenericIntersectionNoCrash1.errors.txt b/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.errors.txt index 4873181c8fb70..4d3463c488c89 100644 --- a/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.errors.txt +++ b/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.errors.txt @@ -1,5 +1,5 @@ -aliasInstantiationExpressionGenericIntersectionNoCrash1.ts(10,1): error TS2352: Conversion of type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' to type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => string)' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. - Type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' is not comparable to type '{ new (): ErrImpl; prototype: ErrImpl; }'. +aliasInstantiationExpressionGenericIntersectionNoCrash1.ts(10,1): error TS2352: Conversion of type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' to type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => string)' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. + Type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' is not comparable to type '{ new (): ErrImpl; prototype: ErrImpl; }'. Type 'ErrImpl' is not comparable to type 'ErrImpl'. Type 'number' is not comparable to type 'string'. @@ -16,8 +16,8 @@ aliasInstantiationExpressionGenericIntersectionNoCrash1.ts(10,1): error TS2352: declare const e: ErrAlias; e as ErrAlias; ~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2352: Conversion of type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' to type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => string)' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. -!!! error TS2352: Type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' is not comparable to type '{ new (): ErrImpl; prototype: ErrImpl; }'. +!!! error TS2352: Conversion of type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' to type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => string)' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. +!!! error TS2352: Type '{ new (): ErrImpl; prototype: ErrImpl; } & (() => number)' is not comparable to type '{ new (): ErrImpl; prototype: ErrImpl; }'. !!! error TS2352: Type 'ErrImpl' is not comparable to type 'ErrImpl'. !!! error TS2352: Type 'number' is not comparable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.types b/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.types index 0ea9c2b1d0181..a75b4759ee8bb 100644 --- a/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.types +++ b/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.types @@ -17,18 +17,18 @@ declare const Err: typeof ErrImpl & (() => T); > : ^^^^^^^^^^^^^^ type ErrAlias = typeof Err; ->ErrAlias : { new (): ErrImpl; prototype: ErrImpl; } & (() => U) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>ErrAlias : { new (): ErrImpl; prototype: ErrImpl; } & (() => U) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Err : typeof ErrImpl & (() => T) > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ declare const e: ErrAlias; ->e : { new (): ErrImpl; prototype: ErrImpl; } & (() => number) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>e : { new (): ErrImpl; prototype: ErrImpl; } & (() => number) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ e as ErrAlias; ->e as ErrAlias : { new (): ErrImpl; prototype: ErrImpl; } & (() => string) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->e : { new (): ErrImpl; prototype: ErrImpl; } & (() => number) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>e as ErrAlias : { new (): ErrImpl; prototype: ErrImpl; } & (() => string) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>e : { new (): ErrImpl; prototype: ErrImpl; } & (() => number) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash2.errors.txt b/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash2.errors.txt index 54c1fc637f6e2..088bc96c5be27 100644 --- a/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash2.errors.txt +++ b/tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash2.errors.txt @@ -1,5 +1,5 @@ aliasInstantiationExpressionGenericIntersectionNoCrash2.ts(15,1): error TS2352: Conversion of type 'Wat' to type 'Wat' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. - Type 'Wat' is not comparable to type '{ new (): Class; prototype: Class; }'. + Type 'Wat' is not comparable to type '{ new (): Class; prototype: Class; }'. Type 'Class' is not comparable to type 'Class'. Type 'number' is not comparable to type 'string'. @@ -22,7 +22,7 @@ aliasInstantiationExpressionGenericIntersectionNoCrash2.ts(15,1): error TS2352: wat as Wat; ~~~~~~~~~~~~~~~~~~ !!! error TS2352: Conversion of type 'Wat' to type 'Wat' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. -!!! error TS2352: Type 'Wat' is not comparable to type '{ new (): Class; prototype: Class; }'. +!!! error TS2352: Type 'Wat' is not comparable to type '{ new (): Class; prototype: Class; }'. !!! error TS2352: Type 'Class' is not comparable to type 'Class'. !!! error TS2352: Type 'number' is not comparable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 825eaeeb3e381..f82cffdc9f890 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -6967,6 +6967,7 @@ declare namespace ts { strictBindCallApply?: boolean; strictNullChecks?: boolean; strictPropertyInitialization?: boolean; + strictInstanceOfTypeParameters?: boolean; stripInternal?: boolean; /** @deprecated */ suppressExcessPropertyErrors?: 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 8bb6097f80145..84223301beb72 100644 --- a/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 8bb6097f80145..84223301beb72 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 8bb6097f80145..84223301beb72 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 b3d05912583d9..be2727ed6a0f7 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 558f4243438d2..0562751d5f827 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 5679f8b921cdf..6fb1e4d0bc5d1 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 535e6a2d97860..f2cf53249f53a 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 da587b6bded7f..0521905f57d09 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 8bb6097f80145..84223301beb72 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 a6e74d92a6a8f..a70126c3ee48d 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 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 41c2964e0e7fa..515ae3e7ff3d3 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 @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictInstanceOfTypeParameters": true, /* Default type arguments to parameter's constraint or 'unknown' instead of 'any' for instance checks. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json b/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json index 27dff8d0b2c57..4b0066474aabf 100644 --- a/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json +++ b/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json @@ -12,7 +12,8 @@ "strictBindCallApply": true, "strictPropertyInitialization": true, "alwaysStrict": true, - "useUnknownInCatchVariables": true + "useUnknownInCatchVariables": true, + "strictInstanceOfTypeParameters": true }, "references": [ { diff --git a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json index a94c9ac06ee71..726dd09af8978 100644 --- a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json +++ b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json @@ -8,6 +8,7 @@ "strictBindCallApply": true, "strictPropertyInitialization": true, "alwaysStrict": true, - "useUnknownInCatchVariables": true + "useUnknownInCatchVariables": true, + "strictInstanceOfTypeParameters": true } } diff --git a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json new file mode 100644 index 0000000000000..06dd3dbb77ab6 --- /dev/null +++ b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictInstanceOfTypeParameters/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "strictInstanceOfTypeParameters": true + } +} diff --git a/tests/baselines/reference/expressionWithJSDocTypeArguments.types b/tests/baselines/reference/expressionWithJSDocTypeArguments.types index c20371ed5b9a1..78f564bc81d2c 100644 --- a/tests/baselines/reference/expressionWithJSDocTypeArguments.types +++ b/tests/baselines/reference/expressionWithJSDocTypeArguments.types @@ -76,34 +76,34 @@ type TComeOnFoo = typeof foo; > : ^ ^^ ^^ ^^^^^^ 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 > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/instantiationExpressions.types b/tests/baselines/reference/instantiationExpressions.types index 84aded72db9a2..6531e4f6181d8 100644 --- a/tests/baselines/reference/instantiationExpressions.types +++ b/tests/baselines/reference/instantiationExpressions.types @@ -149,10 +149,10 @@ function f3() { > : ^^^^^^^^^^ 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 > : ^^^^^^^^ diff --git a/tests/baselines/reference/overrideBaseIntersectionMethod.types b/tests/baselines/reference/overrideBaseIntersectionMethod.types index 7c69c43f76efc..55479b194eaa1 100644 --- a/tests/baselines/reference/overrideBaseIntersectionMethod.types +++ b/tests/baselines/reference/overrideBaseIntersectionMethod.types @@ -10,14 +10,14 @@ type Constructor = new (...args: any[]) => T; > : ^^^^^ 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 > : ^^^^^ @@ -94,8 +94,8 @@ class Foo extends WithLocation(Point) { > : ^^^ >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 > : ^^^^^^^^^^^^ diff --git a/tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt new file mode 100644 index 0000000000000..96cf519b074d9 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.errors.txt @@ -0,0 +1,54 @@ +strictInstanceOfTypeParameters.ts(9,13): error TS2339: Property 'toUpperCase' does not exist on type 'unknown'. +strictInstanceOfTypeParameters.ts(10,5): error TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. +strictInstanceOfTypeParameters.ts(11,7): error TS2349: This expression is not callable. + Type '{}' has no call signatures. +strictInstanceOfTypeParameters.ts(35,12): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== 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..a664336eba6b4 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.js @@ -0,0 +1,70 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParameters.ts] //// + +//// [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..c2176af1de7e5 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.symbols @@ -0,0 +1,110 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParameters.ts] //// + +=== 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..e50901d00f9c4 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParameters.types @@ -0,0 +1,204 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParameters.ts] //// + +=== 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/strictInstanceOfTypeParametersFromAnonymousClass.js b/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.js new file mode 100644 index 0000000000000..2f791ca7d3c67 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.js @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersFromAnonymousClass.ts] //// + +//// [strictInstanceOfTypeParametersFromAnonymousClass.ts] +function MakeClass(someStuff: T) { + return class { + someStuff = someStuff; + }; +} + +const MadeClassNumber = MakeClass(123); +const MadeClassString = MakeClass("foo"); + +const numberInstance = new MadeClassNumber(); +numberInstance.someStuff; + +declare const someInstance: unknown; +if (someInstance instanceof MadeClassNumber) { + someInstance.someStuff; +} + + +//// [strictInstanceOfTypeParametersFromAnonymousClass.js] +function MakeClass(someStuff) { + return /** @class */ (function () { + function class_1() { + this.someStuff = someStuff; + } + return class_1; + }()); +} +var MadeClassNumber = MakeClass(123); +var MadeClassString = MakeClass("foo"); +var numberInstance = new MadeClassNumber(); +numberInstance.someStuff; +if (someInstance instanceof MadeClassNumber) { + someInstance.someStuff; +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.symbols new file mode 100644 index 0000000000000..66c1d1a53354b --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.symbols @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersFromAnonymousClass.ts] //// + +=== strictInstanceOfTypeParametersFromAnonymousClass.ts === +function MakeClass(someStuff: T) { +>MakeClass : Symbol(MakeClass, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 19)) +>someStuff : Symbol(someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 22)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 19)) + + return class { + someStuff = someStuff; +>someStuff : Symbol((Anonymous class).someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 1, 18)) +>someStuff : Symbol(someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 22)) + + }; +} + +const MadeClassNumber = MakeClass(123); +>MadeClassNumber : Symbol(MadeClassNumber, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 6, 5)) +>MakeClass : Symbol(MakeClass, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 0)) + +const MadeClassString = MakeClass("foo"); +>MadeClassString : Symbol(MadeClassString, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 7, 5)) +>MakeClass : Symbol(MakeClass, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 0, 0)) + +const numberInstance = new MadeClassNumber(); +>numberInstance : Symbol(numberInstance, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 9, 5)) +>MadeClassNumber : Symbol(MadeClassNumber, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 6, 5)) + +numberInstance.someStuff; +>numberInstance.someStuff : Symbol((Anonymous class).someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 1, 18)) +>numberInstance : Symbol(numberInstance, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 9, 5)) +>someStuff : Symbol((Anonymous class).someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 1, 18)) + +declare const someInstance: unknown; +>someInstance : Symbol(someInstance, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 12, 13)) + +if (someInstance instanceof MadeClassNumber) { +>someInstance : Symbol(someInstance, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 12, 13)) +>MadeClassNumber : Symbol(MadeClassNumber, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 6, 5)) + + someInstance.someStuff; +>someInstance.someStuff : Symbol((Anonymous class).someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 1, 18)) +>someInstance : Symbol(someInstance, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 12, 13)) +>someStuff : Symbol((Anonymous class).someStuff, Decl(strictInstanceOfTypeParametersFromAnonymousClass.ts, 1, 18)) +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.types b/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.types new file mode 100644 index 0000000000000..99a48ca2800c5 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromAnonymousClass.types @@ -0,0 +1,79 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersFromAnonymousClass.ts] //// + +=== strictInstanceOfTypeParametersFromAnonymousClass.ts === +function MakeClass(someStuff: T) { +>MakeClass : (someStuff: T) => typeof (Anonymous class) +> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>someStuff : T +> : ^ + + return class { +>class { someStuff = someStuff; } : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + + someStuff = someStuff; +>someStuff : T +> : ^ +>someStuff : T +> : ^ + + }; +} + +const MadeClassNumber = MakeClass(123); +>MadeClassNumber : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>MakeClass(123) : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>MakeClass : (someStuff: T) => typeof (Anonymous class) +> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + +const MadeClassString = MakeClass("foo"); +>MadeClassString : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>MakeClass("foo") : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>MakeClass : (someStuff: T) => typeof (Anonymous class) +> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>"foo" : "foo" +> : ^^^^^ + +const numberInstance = new MadeClassNumber(); +>numberInstance : MakeClass.(Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>new MadeClassNumber() : MakeClass.(Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>MadeClassNumber : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + +numberInstance.someStuff; +>numberInstance.someStuff : number +> : ^^^^^^ +>numberInstance : MakeClass.(Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>someStuff : number +> : ^^^^^^ + +declare const someInstance: unknown; +>someInstance : unknown +> : ^^^^^^^ + +if (someInstance instanceof MadeClassNumber) { +>someInstance instanceof MadeClassNumber : boolean +> : ^^^^^^^ +>someInstance : unknown +> : ^^^^^^^ +>MadeClassNumber : typeof (Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + + someInstance.someStuff; +>someInstance.someStuff : unknown +> : ^^^^^^^ +>someInstance : MakeClass.(Anonymous class) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>someStuff : unknown +> : ^^^^^^^ +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt new file mode 100644 index 0000000000000..cc32fc58a3052 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.errors.txt @@ -0,0 +1,36 @@ +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'. +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'. + + +==== 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..759cbeeaffecb --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.js @@ -0,0 +1,56 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts] //// + +//// [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..b6b662b63d818 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.symbols @@ -0,0 +1,73 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts] //// + +=== 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..6c0437cd8adec --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersFromPrivateNameInInExpression.types @@ -0,0 +1,109 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersFromPrivateNameInInExpression.ts] //// + +=== 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/strictInstanceOfTypeParametersWithLocalTypeReferences.js b/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.js new file mode 100644 index 0000000000000..57b6d3d28d0b7 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersWithLocalTypeReferences.ts] //// + +//// [strictInstanceOfTypeParametersWithLocalTypeReferences.ts] +class Box { + value: T; +} + +class BoxBox> { + box: B; +} + +declare const bb: any; +if (bb instanceof BoxBox) { + bb.box.value; +} + + +//// [strictInstanceOfTypeParametersWithLocalTypeReferences.js] +var Box = /** @class */ (function () { + function Box() { + } + return Box; +}()); +var BoxBox = /** @class */ (function () { + function BoxBox() { + } + return BoxBox; +}()); +if (bb instanceof BoxBox) { + bb.box.value; +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.symbols new file mode 100644 index 0000000000000..69ee7e2449d71 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.symbols @@ -0,0 +1,39 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersWithLocalTypeReferences.ts] //// + +=== strictInstanceOfTypeParametersWithLocalTypeReferences.ts === +class Box { +>Box : Symbol(Box, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 10)) + + value: T; +>value : Symbol(Box.value, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 14)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 10)) +} + +class BoxBox> { +>BoxBox : Symbol(BoxBox, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 2, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 13)) +>B : Symbol(B, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 15)) +>Box : Symbol(Box, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 13)) + + box: B; +>box : Symbol(BoxBox.box, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 35)) +>B : Symbol(B, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 15)) +} + +declare const bb: any; +>bb : Symbol(bb, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 8, 13)) + +if (bb instanceof BoxBox) { +>bb : Symbol(bb, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 8, 13)) +>BoxBox : Symbol(BoxBox, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 2, 1)) + + bb.box.value; +>bb.box.value : Symbol(Box.value, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 14)) +>bb.box : Symbol(BoxBox.box, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 35)) +>bb : Symbol(bb, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 8, 13)) +>box : Symbol(BoxBox.box, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 4, 35)) +>value : Symbol(Box.value, Decl(strictInstanceOfTypeParametersWithLocalTypeReferences.ts, 0, 14)) +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.types b/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.types new file mode 100644 index 0000000000000..a88dd979ab1a2 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithLocalTypeReferences.types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersWithLocalTypeReferences.ts] //// + +=== strictInstanceOfTypeParametersWithLocalTypeReferences.ts === +class Box { +>Box : Box +> : ^^^^^^ + + value: T; +>value : T +> : ^ +} + +class BoxBox> { +>BoxBox : BoxBox +> : ^^^^^^^^^^^^ + + box: B; +>box : B +> : ^ +} + +declare const bb: any; +>bb : any + +if (bb instanceof BoxBox) { +>bb instanceof BoxBox : boolean +> : ^^^^^^^ +>bb : any +>BoxBox : typeof BoxBox +> : ^^^^^^^^^^^^^ + + bb.box.value; +>bb.box.value : unknown +> : ^^^^^^^ +>bb.box : Box +> : ^^^^^^^^^^^^ +>bb : BoxBox> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>box : Box +> : ^^^^^^^^^^^^ +>value : unknown +> : ^^^^^^^ +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt new file mode 100644 index 0000000000000..d0edbd988e414 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.errors.txt @@ -0,0 +1,173 @@ +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(9,9): error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant'. + Type 'unknown' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(11,9): error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant<"literal">'. + Type 'unknown' is not assignable to type '"literal"'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(21,9): error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant'. + Type 'string' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(24,9): error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant<"literal">'. + Type 'string' is not assignable to type '"literal"'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(34,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. + Type 'unknown' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(36,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. + Type 'any' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(37,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. + Type 'string' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(38,9): error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant<"literal">'. + Type 'string' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(49,9): error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. + Type 'any' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(50,9): error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. + Type 'string' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(51,9): error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant<"literal">'. + Type 'string' is not assignable to type 'never'. +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'. +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'. +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"'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(75,9): error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. + The types returned by 'f(...)' are incompatible between these types. + Type 'string' is not assignable to type 'never'. +strictInstanceOfTypeParametersWithVarianceAnnotations.ts(78,9): error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant<"literal">'. + The types returned by 'f(...)' are incompatible between these types. + Type 'string' is not assignable to type '"literal"'. + + +==== strictInstanceOfTypeParametersWithVarianceAnnotations.ts (16 errors) ==== + class UnconstrainedCovariant { + x: T; + } + + declare const unc_covariant: unknown; + + if (unc_covariant instanceof UnconstrainedCovariant) { + let unknown_covariant: UnconstrainedCovariant = unc_covariant; + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant'. +!!! error TS2322: Type 'unknown' is not assignable to type 'never'. + let any_covariant: UnconstrainedCovariant = unc_covariant; + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedCovariant' is not assignable to type 'UnconstrainedCovariant<"literal">'. +!!! error TS2322: Type 'unknown' is not assignable to type '"literal"'. + } + + class ConstrainedCovariant { + x: T; + } + + declare const con_covariant: unknown; + + if (con_covariant instanceof ConstrainedCovariant) { + let never_covariant: ConstrainedCovariant = con_covariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let any_covariant: ConstrainedCovariant = con_covariant; + let constraint_covariant: ConstrainedCovariant = con_covariant; + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedCovariant' is not assignable to type 'ConstrainedCovariant<"literal">'. +!!! error TS2322: Type 'string' is not assignable to type '"literal"'. + } + + class UnconstrainedContravariant { + f: (x: T) => void; + } + + declare const unc_contravariant: unknown; + + if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error + ~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. +!!! error TS2322: Type 'unknown' is not assignable to type 'never'. + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. +!!! error TS2322: Type 'any' is not assignable to type 'never'. + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedContravariant' is not assignable to type 'UnconstrainedContravariant<"literal">'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + } + + class ConstrainedContravariant { + f: (x: T) => void; + } + + declare const con_contravariant: unknown; + + if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. +!!! error TS2322: Type 'any' is not assignable to type 'never'. + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedContravariant' is not assignable to type 'ConstrainedContravariant<"literal">'. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + } + + class UnconstrainedInvariant { + f: (x: T) => T; + } + + declare const unc_invariant: unknown; + + if (unc_invariant instanceof UnconstrainedInvariant) { + let unknown_covariant: UnconstrainedInvariant = unc_invariant; + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'unknown' is not assignable to type 'never'. + let any_covariant: UnconstrainedInvariant = unc_invariant; + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'UnconstrainedInvariant' is not assignable to type 'UnconstrainedInvariant<"literal">'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'unknown' is not assignable to type '"literal"'. + } + + class ConstrainedInvariant { + f: (x: T) => T; + } + + declare const con_invariant: unknown; + + if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type 'never'. + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ConstrainedInvariant' is not assignable to type 'ConstrainedInvariant<"literal">'. +!!! error TS2322: The types returned by 'f(...)' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"literal"'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js new file mode 100644 index 0000000000000..1c3e6fa95544c --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.js @@ -0,0 +1,153 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts] //// + +//// [strictInstanceOfTypeParametersWithVarianceAnnotations.ts] +class UnconstrainedCovariant { + x: T; +} + +declare const unc_covariant: unknown; + +if (unc_covariant instanceof UnconstrainedCovariant) { + let unknown_covariant: UnconstrainedCovariant = unc_covariant; + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error + let any_covariant: UnconstrainedCovariant = unc_covariant; + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +} + +class ConstrainedCovariant { + x: T; +} + +declare const con_covariant: unknown; + +if (con_covariant instanceof ConstrainedCovariant) { + let never_covariant: ConstrainedCovariant = con_covariant; // Error + let any_covariant: ConstrainedCovariant = con_covariant; + let constraint_covariant: ConstrainedCovariant = con_covariant; + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +} + +class UnconstrainedContravariant { + f: (x: T) => void; +} + +declare const unc_contravariant: unknown; + +if (unc_contravariant instanceof UnconstrainedContravariant) { + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let never_covariant: UnconstrainedContravariant = unc_contravariant; + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +} + +class ConstrainedContravariant { + f: (x: T) => void; +} + +declare const con_contravariant: unknown; + +if (con_contravariant instanceof ConstrainedContravariant) { + let never_covariant: ConstrainedContravariant = con_contravariant; + let any_covariant: ConstrainedContravariant = con_contravariant; // Error + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +} + +class UnconstrainedInvariant { + f: (x: T) => T; +} + +declare const unc_invariant: unknown; + +if (unc_invariant instanceof UnconstrainedInvariant) { + let unknown_covariant: UnconstrainedInvariant = unc_invariant; + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error + let any_covariant: UnconstrainedInvariant = unc_invariant; + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +} + +class ConstrainedInvariant { + f: (x: T) => T; +} + +declare const con_invariant: unknown; + +if (con_invariant instanceof ConstrainedInvariant) { + let never_covariant: ConstrainedInvariant = con_invariant; // Error + let any_covariant: ConstrainedInvariant = con_invariant; + let constraint_covariant: ConstrainedInvariant = con_invariant; + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +} + + +//// [strictInstanceOfTypeParametersWithVarianceAnnotations.js] +var UnconstrainedCovariant = /** @class */ (function () { + function UnconstrainedCovariant() { + } + return UnconstrainedCovariant; +}()); +if (unc_covariant instanceof UnconstrainedCovariant) { + var unknown_covariant = unc_covariant; + var never_covariant = unc_covariant; // Error + var any_covariant = unc_covariant; + var sub_covariant = unc_covariant; // Error +} +var ConstrainedCovariant = /** @class */ (function () { + function ConstrainedCovariant() { + } + return ConstrainedCovariant; +}()); +if (con_covariant instanceof ConstrainedCovariant) { + var never_covariant = con_covariant; // Error + var any_covariant = con_covariant; + var constraint_covariant = con_covariant; + var sub_covariant = con_covariant; // Error +} +var UnconstrainedContravariant = /** @class */ (function () { + function UnconstrainedContravariant() { + } + return UnconstrainedContravariant; +}()); +if (unc_contravariant instanceof UnconstrainedContravariant) { + var unknown_covariant = unc_contravariant; // Error + var never_covariant = unc_contravariant; + var any_covariant = unc_contravariant; // Error + var constraint_covariant = unc_contravariant; // Error + var sub_covariant = unc_contravariant; // Error +} +var ConstrainedContravariant = /** @class */ (function () { + function ConstrainedContravariant() { + } + return ConstrainedContravariant; +}()); +if (con_contravariant instanceof ConstrainedContravariant) { + var never_covariant = con_contravariant; + var any_covariant = con_contravariant; // Error + var constraint_covariant = con_contravariant; // Error + var sub_covariant = con_contravariant; // Error +} +var UnconstrainedInvariant = /** @class */ (function () { + function UnconstrainedInvariant() { + } + return UnconstrainedInvariant; +}()); +if (unc_invariant instanceof UnconstrainedInvariant) { + var unknown_covariant = unc_invariant; + var never_covariant = unc_invariant; // Error + var any_covariant = unc_invariant; + var constraint_covariant = unc_invariant; // Error + var sub_covariant = unc_invariant; // Error +} +var ConstrainedInvariant = /** @class */ (function () { + function ConstrainedInvariant() { + } + return ConstrainedInvariant; +}()); +if (con_invariant instanceof ConstrainedInvariant) { + var never_covariant = con_invariant; // Error + var any_covariant = con_invariant; + var constraint_covariant = con_invariant; + var sub_covariant = con_invariant; // Error +} diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols new file mode 100644 index 0000000000000..c03f4471c5289 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.symbols @@ -0,0 +1,241 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts] //// + +=== strictInstanceOfTypeParametersWithVarianceAnnotations.ts === +class UnconstrainedCovariant { +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) + + x: T; +>x : Symbol(UnconstrainedCovariant.x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 37)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 29)) +} + +declare const unc_covariant: unknown; +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + +if (unc_covariant instanceof UnconstrainedCovariant) { +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) + + let unknown_covariant: UnconstrainedCovariant = unc_covariant; +>unknown_covariant : Symbol(unknown_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 7, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 8, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + + let any_covariant: UnconstrainedCovariant = unc_covariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 9, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) + + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 10, 7)) +>UnconstrainedCovariant : Symbol(UnconstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 0, 0)) +>unc_covariant : Symbol(unc_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 4, 13)) +} + +class ConstrainedCovariant { +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 27)) + + x: T; +>x : Symbol(ConstrainedCovariant.x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 50)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 13, 27)) +} + +declare const con_covariant: unknown; +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + +if (con_covariant instanceof ConstrainedCovariant) { +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) + + let never_covariant: ConstrainedCovariant = con_covariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 20, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + + let any_covariant: ConstrainedCovariant = con_covariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 21, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + + let constraint_covariant: ConstrainedCovariant = con_covariant; +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 22, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) + + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 23, 7)) +>ConstrainedCovariant : Symbol(ConstrainedCovariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 11, 1)) +>con_covariant : Symbol(con_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 17, 13)) +} + +class UnconstrainedContravariant { +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 33)) + + f: (x: T) => void; +>f : Symbol(UnconstrainedContravariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 40)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 27, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 26, 33)) +} + +declare const unc_contravariant: unknown; +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + +if (unc_contravariant instanceof UnconstrainedContravariant) { +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) + + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>unknown_covariant : Symbol(unknown_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 33, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let never_covariant: UnconstrainedContravariant = unc_contravariant; +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 34, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 35, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 36, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) + + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 37, 7)) +>UnconstrainedContravariant : Symbol(UnconstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 24, 1)) +>unc_contravariant : Symbol(unc_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 30, 13)) +} + +class ConstrainedContravariant { +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 31)) + + f: (x: T) => void; +>f : Symbol(ConstrainedContravariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 53)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 41, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 40, 31)) +} + +declare const con_contravariant: unknown; +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + +if (con_contravariant instanceof ConstrainedContravariant) { +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) + + let never_covariant: ConstrainedContravariant = con_contravariant; +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 47, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + + let any_covariant: ConstrainedContravariant = con_contravariant; // Error +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 48, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 49, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) + + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 50, 7)) +>ConstrainedContravariant : Symbol(ConstrainedContravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 38, 1)) +>con_contravariant : Symbol(con_contravariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 44, 13)) +} + +class UnconstrainedInvariant { +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 29)) + + f: (x: T) => T; +>f : Symbol(UnconstrainedInvariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 40)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 54, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 29)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 53, 29)) +} + +declare const unc_invariant: unknown; +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + +if (unc_invariant instanceof UnconstrainedInvariant) { +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) + + let unknown_covariant: UnconstrainedInvariant = unc_invariant; +>unknown_covariant : Symbol(unknown_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 60, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 61, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let any_covariant: UnconstrainedInvariant = unc_invariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 62, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 63, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) + + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 64, 7)) +>UnconstrainedInvariant : Symbol(UnconstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 51, 1)) +>unc_invariant : Symbol(unc_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 57, 13)) +} + +class ConstrainedInvariant { +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) + + f: (x: T) => T; +>f : Symbol(ConstrainedInvariant.f, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 53)) +>x : Symbol(x, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 68, 8)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) +>T : Symbol(T, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 67, 27)) +} + +declare const con_invariant: unknown; +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + +if (con_invariant instanceof ConstrainedInvariant) { +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) + + let never_covariant: ConstrainedInvariant = con_invariant; // Error +>never_covariant : Symbol(never_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 74, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + + let any_covariant: ConstrainedInvariant = con_invariant; +>any_covariant : Symbol(any_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 75, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + + let constraint_covariant: ConstrainedInvariant = con_invariant; +>constraint_covariant : Symbol(constraint_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 76, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) + + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +>sub_covariant : Symbol(sub_covariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 77, 7)) +>ConstrainedInvariant : Symbol(ConstrainedInvariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 65, 1)) +>con_invariant : Symbol(con_invariant, Decl(strictInstanceOfTypeParametersWithVarianceAnnotations.ts, 71, 13)) +} + diff --git a/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types new file mode 100644 index 0000000000000..5592c0fa3ce02 --- /dev/null +++ b/tests/baselines/reference/strictInstanceOfTypeParametersWithVarianceAnnotations.types @@ -0,0 +1,299 @@ +//// [tests/cases/compiler/strictInstanceOfTypeParametersWithVarianceAnnotations.ts] //// + +=== strictInstanceOfTypeParametersWithVarianceAnnotations.ts === +class UnconstrainedCovariant { +>UnconstrainedCovariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + x: T; +>x : T +> : ^ +} + +declare const unc_covariant: unknown; +>unc_covariant : unknown +> : ^^^^^^^ + +if (unc_covariant instanceof UnconstrainedCovariant) { +>unc_covariant instanceof UnconstrainedCovariant : boolean +> : ^^^^^^^ +>unc_covariant : unknown +> : ^^^^^^^ +>UnconstrainedCovariant : typeof UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let unknown_covariant: UnconstrainedCovariant = unc_covariant; +>unknown_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let never_covariant: UnconstrainedCovariant = unc_covariant; // Error +>never_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let any_covariant: UnconstrainedCovariant = unc_covariant; +>any_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let sub_covariant: UnconstrainedCovariant<"literal"> = unc_covariant; // Error +>sub_covariant : UnconstrainedCovariant<"literal"> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_covariant : UnconstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +class ConstrainedCovariant { +>ConstrainedCovariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^ + + x: T; +>x : T +> : ^ +} + +declare const con_covariant: unknown; +>con_covariant : unknown +> : ^^^^^^^ + +if (con_covariant instanceof ConstrainedCovariant) { +>con_covariant instanceof ConstrainedCovariant : boolean +> : ^^^^^^^ +>con_covariant : unknown +> : ^^^^^^^ +>ConstrainedCovariant : typeof ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let never_covariant: ConstrainedCovariant = con_covariant; // Error +>never_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let any_covariant: ConstrainedCovariant = con_covariant; +>any_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let constraint_covariant: ConstrainedCovariant = con_covariant; +>constraint_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let sub_covariant: ConstrainedCovariant<"literal"> = con_covariant; // Error +>sub_covariant : ConstrainedCovariant<"literal"> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_covariant : ConstrainedCovariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +class UnconstrainedContravariant { +>UnconstrainedContravariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + f: (x: T) => void; +>f : (x: T) => void +> : ^ ^^ ^^^^^ +>x : T +> : ^ +} + +declare const unc_contravariant: unknown; +>unc_contravariant : unknown +> : ^^^^^^^ + +if (unc_contravariant instanceof UnconstrainedContravariant) { +>unc_contravariant instanceof UnconstrainedContravariant : boolean +> : ^^^^^^^ +>unc_contravariant : unknown +> : ^^^^^^^ +>UnconstrainedContravariant : typeof UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let unknown_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>unknown_covariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_contravariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let never_covariant: UnconstrainedContravariant = unc_contravariant; +>never_covariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_contravariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let any_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>any_covariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_contravariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let constraint_covariant: UnconstrainedContravariant = unc_contravariant; // Error +>constraint_covariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_contravariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let sub_covariant: UnconstrainedContravariant<"literal"> = unc_contravariant; // Error +>sub_covariant : UnconstrainedContravariant<"literal"> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_contravariant : UnconstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +class ConstrainedContravariant { +>ConstrainedContravariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + f: (x: T) => void; +>f : (x: T) => void +> : ^ ^^ ^^^^^ +>x : T +> : ^ +} + +declare const con_contravariant: unknown; +>con_contravariant : unknown +> : ^^^^^^^ + +if (con_contravariant instanceof ConstrainedContravariant) { +>con_contravariant instanceof ConstrainedContravariant : boolean +> : ^^^^^^^ +>con_contravariant : unknown +> : ^^^^^^^ +>ConstrainedContravariant : typeof ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let never_covariant: ConstrainedContravariant = con_contravariant; +>never_covariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_contravariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let any_covariant: ConstrainedContravariant = con_contravariant; // Error +>any_covariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_contravariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let constraint_covariant: ConstrainedContravariant = con_contravariant; // Error +>constraint_covariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_contravariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let sub_covariant: ConstrainedContravariant<"literal"> = con_contravariant; // Error +>sub_covariant : ConstrainedContravariant<"literal"> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_contravariant : ConstrainedContravariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +class UnconstrainedInvariant { +>UnconstrainedInvariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + f: (x: T) => T; +>f : (x: T) => T +> : ^ ^^ ^^^^^ +>x : T +> : ^ +} + +declare const unc_invariant: unknown; +>unc_invariant : unknown +> : ^^^^^^^ + +if (unc_invariant instanceof UnconstrainedInvariant) { +>unc_invariant instanceof UnconstrainedInvariant : boolean +> : ^^^^^^^ +>unc_invariant : unknown +> : ^^^^^^^ +>UnconstrainedInvariant : typeof UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let unknown_covariant: UnconstrainedInvariant = unc_invariant; +>unknown_covariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_invariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let never_covariant: UnconstrainedInvariant = unc_invariant; // Error +>never_covariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_invariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let any_covariant: UnconstrainedInvariant = unc_invariant; +>any_covariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_invariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let constraint_covariant: UnconstrainedInvariant = unc_invariant; // Error +>constraint_covariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_invariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let sub_covariant: UnconstrainedInvariant<"literal"> = unc_invariant; // Error +>sub_covariant : UnconstrainedInvariant<"literal"> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>unc_invariant : UnconstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +class ConstrainedInvariant { +>ConstrainedInvariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^ + + f: (x: T) => T; +>f : (x: T) => T +> : ^ ^^ ^^^^^ +>x : T +> : ^ +} + +declare const con_invariant: unknown; +>con_invariant : unknown +> : ^^^^^^^ + +if (con_invariant instanceof ConstrainedInvariant) { +>con_invariant instanceof ConstrainedInvariant : boolean +> : ^^^^^^^ +>con_invariant : unknown +> : ^^^^^^^ +>ConstrainedInvariant : typeof ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let never_covariant: ConstrainedInvariant = con_invariant; // Error +>never_covariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_invariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let any_covariant: ConstrainedInvariant = con_invariant; +>any_covariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_invariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let constraint_covariant: ConstrainedInvariant = con_invariant; +>constraint_covariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_invariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let sub_covariant: ConstrainedInvariant<"literal"> = con_invariant; // Error +>sub_covariant : ConstrainedInvariant<"literal"> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>con_invariant : ConstrainedInvariant +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} +