From 08cd0b3700cbe62a170d9c5693170fc0210d598a Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 29 May 2019 12:42:43 -0700 Subject: [PATCH 1/3] Use proper variances when inferring between type alias instantiations --- src/compiler/checker.ts | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 85b3641f004..99ae67d764f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15171,11 +15171,7 @@ namespace ts { if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) { // Source and target are types originating in the same generic type alias declaration. // Simply infer from source type arguments to target type arguments. - const sourceTypes = source.aliasTypeArguments; - const targetTypes = target.aliasTypeArguments!; - for (let i = 0; i < sourceTypes.length; i++) { - inferFromTypes(sourceTypes[i], targetTypes[i]); - } + inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments!, getAliasVariances(source.aliasSymbol)); return; } if (source.flags & TypeFlags.Union && target.flags & TypeFlags.Union && !(source.flags & TypeFlags.EnumLiteral && target.flags & TypeFlags.EnumLiteral) || @@ -15281,18 +15277,7 @@ namespace ts { } if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source).target === (target).target) { // If source and target are references to the same generic type, infer from type arguments - const sourceTypes = (source).typeArguments || emptyArray; - const targetTypes = (target).typeArguments || emptyArray; - const count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length; - const variances = getVariances((source).target); - for (let i = 0; i < count; i++) { - if (i < variances.length && (variances[i] & VarianceFlags.VarianceMask) === VarianceFlags.Contravariant) { - inferFromContravariantTypes(sourceTypes[i], targetTypes[i]); - } - else { - inferFromTypes(sourceTypes[i], targetTypes[i]); - } - } + inferFromTypeArguments((source).typeArguments || emptyArray, (target).typeArguments || emptyArray, getVariances((source).target)); } else if (source.flags & TypeFlags.Index && target.flags & TypeFlags.Index) { contravariant = !contravariant; @@ -15412,6 +15397,18 @@ namespace ts { } } + function inferFromTypeArguments(sourceTypes: readonly Type[], targetTypes: readonly Type[], variances: readonly VarianceFlags[]) { + const count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length; + for (let i = 0; i < count; i++) { + if (i < variances.length && (variances[i] & VarianceFlags.VarianceMask) === VarianceFlags.Contravariant) { + inferFromContravariantTypes(sourceTypes[i], targetTypes[i]); + } + else { + inferFromTypes(sourceTypes[i], targetTypes[i]); + } + } + } + function inferFromContravariantTypes(source: Type, target: Type) { if (strictFunctionTypes || priority & InferencePriority.AlwaysStrict) { contravariant = !contravariant; From 22475e8958ce2892c5311c3249165548606b10e8 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 29 May 2019 13:09:51 -0700 Subject: [PATCH 2/3] Add regression tests --- .../contravariantTypeAliasInference.ts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 tests/cases/compiler/contravariantTypeAliasInference.ts diff --git a/tests/cases/compiler/contravariantTypeAliasInference.ts b/tests/cases/compiler/contravariantTypeAliasInference.ts new file mode 100644 index 00000000000..77044eeae76 --- /dev/null +++ b/tests/cases/compiler/contravariantTypeAliasInference.ts @@ -0,0 +1,19 @@ +// @strict: true + +type Func1 = (x: T) => void; +type Func2 = ((x: T) => void) | undefined; + +declare let f1: Func1; +declare let f2: Func1<"a">; + +declare function foo(f1: Func1, f2: Func1): void; + +foo(f1, f2); + +declare let g1: Func2; +declare let g2: Func2<"a">; + +declare function bar(g1: Func2, g2: Func2): void; + +bar(f1, f2); +bar(g1, g2); From bb412ab73b1cbc9eaa38145bc733b3325c55f30d Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 29 May 2019 13:10:01 -0700 Subject: [PATCH 3/3] Accept new baselines --- .../contravariantTypeAliasInference.js | 25 ++++++++ .../contravariantTypeAliasInference.symbols | 64 +++++++++++++++++++ .../contravariantTypeAliasInference.types | 49 ++++++++++++++ 3 files changed, 138 insertions(+) create mode 100644 tests/baselines/reference/contravariantTypeAliasInference.js create mode 100644 tests/baselines/reference/contravariantTypeAliasInference.symbols create mode 100644 tests/baselines/reference/contravariantTypeAliasInference.types diff --git a/tests/baselines/reference/contravariantTypeAliasInference.js b/tests/baselines/reference/contravariantTypeAliasInference.js new file mode 100644 index 00000000000..a0a7b45db91 --- /dev/null +++ b/tests/baselines/reference/contravariantTypeAliasInference.js @@ -0,0 +1,25 @@ +//// [contravariantTypeAliasInference.ts] +type Func1 = (x: T) => void; +type Func2 = ((x: T) => void) | undefined; + +declare let f1: Func1; +declare let f2: Func1<"a">; + +declare function foo(f1: Func1, f2: Func1): void; + +foo(f1, f2); + +declare let g1: Func2; +declare let g2: Func2<"a">; + +declare function bar(g1: Func2, g2: Func2): void; + +bar(f1, f2); +bar(g1, g2); + + +//// [contravariantTypeAliasInference.js] +"use strict"; +foo(f1, f2); +bar(f1, f2); +bar(g1, g2); diff --git a/tests/baselines/reference/contravariantTypeAliasInference.symbols b/tests/baselines/reference/contravariantTypeAliasInference.symbols new file mode 100644 index 00000000000..ff34d3ea17e --- /dev/null +++ b/tests/baselines/reference/contravariantTypeAliasInference.symbols @@ -0,0 +1,64 @@ +=== tests/cases/compiler/contravariantTypeAliasInference.ts === +type Func1 = (x: T) => void; +>Func1 : Symbol(Func1, Decl(contravariantTypeAliasInference.ts, 0, 0)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 0, 11)) +>x : Symbol(x, Decl(contravariantTypeAliasInference.ts, 0, 17)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 0, 11)) + +type Func2 = ((x: T) => void) | undefined; +>Func2 : Symbol(Func2, Decl(contravariantTypeAliasInference.ts, 0, 31)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 1, 11)) +>x : Symbol(x, Decl(contravariantTypeAliasInference.ts, 1, 18)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 1, 11)) + +declare let f1: Func1; +>f1 : Symbol(f1, Decl(contravariantTypeAliasInference.ts, 3, 11)) +>Func1 : Symbol(Func1, Decl(contravariantTypeAliasInference.ts, 0, 0)) + +declare let f2: Func1<"a">; +>f2 : Symbol(f2, Decl(contravariantTypeAliasInference.ts, 4, 11)) +>Func1 : Symbol(Func1, Decl(contravariantTypeAliasInference.ts, 0, 0)) + +declare function foo(f1: Func1, f2: Func1): void; +>foo : Symbol(foo, Decl(contravariantTypeAliasInference.ts, 4, 27)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 6, 21)) +>f1 : Symbol(f1, Decl(contravariantTypeAliasInference.ts, 6, 24)) +>Func1 : Symbol(Func1, Decl(contravariantTypeAliasInference.ts, 0, 0)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 6, 21)) +>f2 : Symbol(f2, Decl(contravariantTypeAliasInference.ts, 6, 37)) +>Func1 : Symbol(Func1, Decl(contravariantTypeAliasInference.ts, 0, 0)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 6, 21)) + +foo(f1, f2); +>foo : Symbol(foo, Decl(contravariantTypeAliasInference.ts, 4, 27)) +>f1 : Symbol(f1, Decl(contravariantTypeAliasInference.ts, 3, 11)) +>f2 : Symbol(f2, Decl(contravariantTypeAliasInference.ts, 4, 11)) + +declare let g1: Func2; +>g1 : Symbol(g1, Decl(contravariantTypeAliasInference.ts, 10, 11)) +>Func2 : Symbol(Func2, Decl(contravariantTypeAliasInference.ts, 0, 31)) + +declare let g2: Func2<"a">; +>g2 : Symbol(g2, Decl(contravariantTypeAliasInference.ts, 11, 11)) +>Func2 : Symbol(Func2, Decl(contravariantTypeAliasInference.ts, 0, 31)) + +declare function bar(g1: Func2, g2: Func2): void; +>bar : Symbol(bar, Decl(contravariantTypeAliasInference.ts, 11, 27)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 13, 21)) +>g1 : Symbol(g1, Decl(contravariantTypeAliasInference.ts, 13, 24)) +>Func2 : Symbol(Func2, Decl(contravariantTypeAliasInference.ts, 0, 31)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 13, 21)) +>g2 : Symbol(g2, Decl(contravariantTypeAliasInference.ts, 13, 37)) +>Func2 : Symbol(Func2, Decl(contravariantTypeAliasInference.ts, 0, 31)) +>T : Symbol(T, Decl(contravariantTypeAliasInference.ts, 13, 21)) + +bar(f1, f2); +>bar : Symbol(bar, Decl(contravariantTypeAliasInference.ts, 11, 27)) +>f1 : Symbol(f1, Decl(contravariantTypeAliasInference.ts, 3, 11)) +>f2 : Symbol(f2, Decl(contravariantTypeAliasInference.ts, 4, 11)) + +bar(g1, g2); +>bar : Symbol(bar, Decl(contravariantTypeAliasInference.ts, 11, 27)) +>g1 : Symbol(g1, Decl(contravariantTypeAliasInference.ts, 10, 11)) +>g2 : Symbol(g2, Decl(contravariantTypeAliasInference.ts, 11, 11)) + diff --git a/tests/baselines/reference/contravariantTypeAliasInference.types b/tests/baselines/reference/contravariantTypeAliasInference.types new file mode 100644 index 00000000000..9ff197cdfce --- /dev/null +++ b/tests/baselines/reference/contravariantTypeAliasInference.types @@ -0,0 +1,49 @@ +=== tests/cases/compiler/contravariantTypeAliasInference.ts === +type Func1 = (x: T) => void; +>Func1 : Func1 +>x : T + +type Func2 = ((x: T) => void) | undefined; +>Func2 : Func2 +>x : T + +declare let f1: Func1; +>f1 : Func1 + +declare let f2: Func1<"a">; +>f2 : Func1<"a"> + +declare function foo(f1: Func1, f2: Func1): void; +>foo : (f1: Func1, f2: Func1) => void +>f1 : Func1 +>f2 : Func1 + +foo(f1, f2); +>foo(f1, f2) : void +>foo : (f1: Func1, f2: Func1) => void +>f1 : Func1 +>f2 : Func1<"a"> + +declare let g1: Func2; +>g1 : Func2 + +declare let g2: Func2<"a">; +>g2 : Func2<"a"> + +declare function bar(g1: Func2, g2: Func2): void; +>bar : (g1: Func2, g2: Func2) => void +>g1 : Func2 +>g2 : Func2 + +bar(f1, f2); +>bar(f1, f2) : void +>bar : (g1: Func2, g2: Func2) => void +>f1 : Func1 +>f2 : Func1<"a"> + +bar(g1, g2); +>bar(g1, g2) : void +>bar : (g1: Func2, g2: Func2) => void +>g1 : Func2 +>g2 : Func2<"a"> +