diff --git a/tests/baselines/reference/strictFunctionTypesErrors.symbols b/tests/baselines/reference/strictFunctionTypesErrors.symbols
new file mode 100644
index 00000000000..ce3a81f524f
--- /dev/null
+++ b/tests/baselines/reference/strictFunctionTypesErrors.symbols
@@ -0,0 +1,366 @@
+=== tests/cases/compiler/strictFunctionTypesErrors.ts ===
+export {}
+
+
+declare let f1: (x: Object) => Object;
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+>x : Symbol(x, Decl(strictFunctionTypesErrors.ts, 3, 17))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let f2: (x: Object) => string;
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+>x : Symbol(x, Decl(strictFunctionTypesErrors.ts, 4, 17))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let f3: (x: string) => Object;
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+>x : Symbol(x, Decl(strictFunctionTypesErrors.ts, 5, 17))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let f4: (x: string) => string;
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+>x : Symbol(x, Decl(strictFunctionTypesErrors.ts, 6, 17))
+
+f1 = f2;  // Ok
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+
+f1 = f3;  // Error
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+
+f1 = f4;  // Error
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+
+f2 = f1;  // Error
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+
+f2 = f3;  // Error
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+
+f2 = f4;  // Error
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+
+f3 = f1;  // Ok
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+
+f3 = f2;  // Ok
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+
+f3 = f4;  // Ok
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+
+f4 = f1;  // Error
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+>f1 : Symbol(f1, Decl(strictFunctionTypesErrors.ts, 3, 11))
+
+f4 = f2;  // Ok
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+>f2 : Symbol(f2, Decl(strictFunctionTypesErrors.ts, 4, 11))
+
+f4 = f3;  // Error
+>f4 : Symbol(f4, Decl(strictFunctionTypesErrors.ts, 6, 11))
+>f3 : Symbol(f3, Decl(strictFunctionTypesErrors.ts, 5, 11))
+
+type Func<T, U> = (x: T) => U;
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 24, 10))
+>U : Symbol(U, Decl(strictFunctionTypesErrors.ts, 24, 12))
+>x : Symbol(x, Decl(strictFunctionTypesErrors.ts, 24, 19))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 24, 10))
+>U : Symbol(U, Decl(strictFunctionTypesErrors.ts, 24, 12))
+
+declare let g1: Func<Object, Object>;
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let g2: Func<Object, string>;
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let g3: Func<string, Object>;
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let g4: Func<string, string>;
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+
+g1 = g2;  // Ok
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+
+g1 = g3;  // Error
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+
+g1 = g4;  // Error
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+
+g2 = g1;  // Error
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+
+g2 = g3;  // Error
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+
+g2 = g4;  // Error
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+
+g3 = g1;  // Ok
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+
+g3 = g2;  // Ok
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+
+g3 = g4;  // Ok
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+
+g4 = g1;  // Error
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+>g1 : Symbol(g1, Decl(strictFunctionTypesErrors.ts, 26, 11))
+
+g4 = g2;  // Ok
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+>g2 : Symbol(g2, Decl(strictFunctionTypesErrors.ts, 27, 11))
+
+g4 = g3;  // Error
+>g4 : Symbol(g4, Decl(strictFunctionTypesErrors.ts, 29, 11))
+>g3 : Symbol(g3, Decl(strictFunctionTypesErrors.ts, 28, 11))
+
+declare let h1: Func<Func<Object, void>, Object>;
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let h2: Func<Func<Object, void>, string>;
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let h3: Func<Func<string, void>, Object>;
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let h4: Func<Func<string, void>, string>;
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+
+h1 = h2;  // Ok
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+
+h1 = h3;  // Ok
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+
+h1 = h4;  // Ok
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+
+h2 = h1;  // Error
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+
+h2 = h3;  // Error
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+
+h2 = h4;  // Ok
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+
+h3 = h1;  // Error
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+
+h3 = h2;  // Error
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+
+h3 = h4;  // Ok
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+
+h4 = h1;  // Error
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+>h1 : Symbol(h1, Decl(strictFunctionTypesErrors.ts, 47, 11))
+
+h4 = h2;  // Error
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+>h2 : Symbol(h2, Decl(strictFunctionTypesErrors.ts, 48, 11))
+
+h4 = h3;  // Error
+>h4 : Symbol(h4, Decl(strictFunctionTypesErrors.ts, 50, 11))
+>h3 : Symbol(h3, Decl(strictFunctionTypesErrors.ts, 49, 11))
+
+declare let i1: Func<Object, Func<Object, void>>;
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let i2: Func<Object, Func<string, void>>;
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+
+declare let i3: Func<string, Func<Object, void>>;
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+declare let i4: Func<string, Func<string, void>>;
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+>Func : Symbol(Func, Decl(strictFunctionTypesErrors.ts, 22, 8))
+
+i1 = i2;  // Error
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+
+i1 = i3;  // Error
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+
+i1 = i4;  // Error
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+
+i2 = i1;  // Ok
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+
+i2 = i3;  // Error
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+
+i2 = i4;  // Error
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+
+i3 = i1;  // Ok
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+
+i3 = i2;  // Error
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+
+i3 = i4;  // Error
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+
+i4 = i1;  // Ok
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+>i1 : Symbol(i1, Decl(strictFunctionTypesErrors.ts, 68, 11))
+
+i4 = i2;  // Ok
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+>i2 : Symbol(i2, Decl(strictFunctionTypesErrors.ts, 69, 11))
+
+i4 = i3;  // Ok
+>i4 : Symbol(i4, Decl(strictFunctionTypesErrors.ts, 71, 11))
+>i3 : Symbol(i3, Decl(strictFunctionTypesErrors.ts, 70, 11))
+
+interface Animal { animal: void }
+>Animal : Symbol(Animal, Decl(strictFunctionTypesErrors.ts, 87, 8))
+>animal : Symbol(Animal.animal, Decl(strictFunctionTypesErrors.ts, 89, 18))
+
+interface Dog extends Animal { dog: void }
+>Dog : Symbol(Dog, Decl(strictFunctionTypesErrors.ts, 89, 33))
+>Animal : Symbol(Animal, Decl(strictFunctionTypesErrors.ts, 87, 8))
+>dog : Symbol(Dog.dog, Decl(strictFunctionTypesErrors.ts, 90, 30))
+
+interface Cat extends Animal { cat: void }
+>Cat : Symbol(Cat, Decl(strictFunctionTypesErrors.ts, 90, 42))
+>Animal : Symbol(Animal, Decl(strictFunctionTypesErrors.ts, 87, 8))
+>cat : Symbol(Cat.cat, Decl(strictFunctionTypesErrors.ts, 91, 30))
+
+interface Comparer1<T> {
+>Comparer1 : Symbol(Comparer1, Decl(strictFunctionTypesErrors.ts, 91, 42))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 93, 20))
+
+    compare(a: T, b: T): number;
+>compare : Symbol(Comparer1.compare, Decl(strictFunctionTypesErrors.ts, 93, 24))
+>a : Symbol(a, Decl(strictFunctionTypesErrors.ts, 94, 12))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 93, 20))
+>b : Symbol(b, Decl(strictFunctionTypesErrors.ts, 94, 17))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 93, 20))
+}
+
+declare let animalComparer1: Comparer1<Animal>;
+>animalComparer1 : Symbol(animalComparer1, Decl(strictFunctionTypesErrors.ts, 97, 11))
+>Comparer1 : Symbol(Comparer1, Decl(strictFunctionTypesErrors.ts, 91, 42))
+>Animal : Symbol(Animal, Decl(strictFunctionTypesErrors.ts, 87, 8))
+
+declare let dogComparer1: Comparer1<Dog>;
+>dogComparer1 : Symbol(dogComparer1, Decl(strictFunctionTypesErrors.ts, 98, 11))
+>Comparer1 : Symbol(Comparer1, Decl(strictFunctionTypesErrors.ts, 91, 42))
+>Dog : Symbol(Dog, Decl(strictFunctionTypesErrors.ts, 89, 33))
+
+animalComparer1 = dogComparer1;  // Ok
+>animalComparer1 : Symbol(animalComparer1, Decl(strictFunctionTypesErrors.ts, 97, 11))
+>dogComparer1 : Symbol(dogComparer1, Decl(strictFunctionTypesErrors.ts, 98, 11))
+
+dogComparer1 = animalComparer1;  // Ok
+>dogComparer1 : Symbol(dogComparer1, Decl(strictFunctionTypesErrors.ts, 98, 11))
+>animalComparer1 : Symbol(animalComparer1, Decl(strictFunctionTypesErrors.ts, 97, 11))
+
+interface Comparer2<T> {
+>Comparer2 : Symbol(Comparer2, Decl(strictFunctionTypesErrors.ts, 101, 31))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 103, 20))
+
+    compare: (a: T, b: T) => number;
+>compare : Symbol(Comparer2.compare, Decl(strictFunctionTypesErrors.ts, 103, 24))
+>a : Symbol(a, Decl(strictFunctionTypesErrors.ts, 104, 14))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 103, 20))
+>b : Symbol(b, Decl(strictFunctionTypesErrors.ts, 104, 19))
+>T : Symbol(T, Decl(strictFunctionTypesErrors.ts, 103, 20))
+}
+
+declare let animalComparer2: Comparer2<Animal>;
+>animalComparer2 : Symbol(animalComparer2, Decl(strictFunctionTypesErrors.ts, 107, 11))
+>Comparer2 : Symbol(Comparer2, Decl(strictFunctionTypesErrors.ts, 101, 31))
+>Animal : Symbol(Animal, Decl(strictFunctionTypesErrors.ts, 87, 8))
+
+declare let dogComparer2: Comparer2<Dog>;
+>dogComparer2 : Symbol(dogComparer2, Decl(strictFunctionTypesErrors.ts, 108, 11))
+>Comparer2 : Symbol(Comparer2, Decl(strictFunctionTypesErrors.ts, 101, 31))
+>Dog : Symbol(Dog, Decl(strictFunctionTypesErrors.ts, 89, 33))
+
+animalComparer2 = dogComparer2;  // Error
+>animalComparer2 : Symbol(animalComparer2, Decl(strictFunctionTypesErrors.ts, 107, 11))
+>dogComparer2 : Symbol(dogComparer2, Decl(strictFunctionTypesErrors.ts, 108, 11))
+
+dogComparer2 = animalComparer2;  // Ok
+>dogComparer2 : Symbol(dogComparer2, Decl(strictFunctionTypesErrors.ts, 108, 11))
+>animalComparer2 : Symbol(animalComparer2, Decl(strictFunctionTypesErrors.ts, 107, 11))
+
diff --git a/tests/baselines/reference/strictFunctionTypesErrors.types b/tests/baselines/reference/strictFunctionTypesErrors.types
new file mode 100644
index 00000000000..f2d3b52a5b9
--- /dev/null
+++ b/tests/baselines/reference/strictFunctionTypesErrors.types
@@ -0,0 +1,418 @@
+=== tests/cases/compiler/strictFunctionTypesErrors.ts ===
+export {}
+
+
+declare let f1: (x: Object) => Object;
+>f1 : (x: Object) => Object
+>x : Object
+>Object : Object
+>Object : Object
+
+declare let f2: (x: Object) => string;
+>f2 : (x: Object) => string
+>x : Object
+>Object : Object
+
+declare let f3: (x: string) => Object;
+>f3 : (x: string) => Object
+>x : string
+>Object : Object
+
+declare let f4: (x: string) => string;
+>f4 : (x: string) => string
+>x : string
+
+f1 = f2;  // Ok
+>f1 = f2 : (x: Object) => string
+>f1 : (x: Object) => Object
+>f2 : (x: Object) => string
+
+f1 = f3;  // Error
+>f1 = f3 : (x: string) => Object
+>f1 : (x: Object) => Object
+>f3 : (x: string) => Object
+
+f1 = f4;  // Error
+>f1 = f4 : (x: string) => string
+>f1 : (x: Object) => Object
+>f4 : (x: string) => string
+
+f2 = f1;  // Error
+>f2 = f1 : (x: Object) => Object
+>f2 : (x: Object) => string
+>f1 : (x: Object) => Object
+
+f2 = f3;  // Error
+>f2 = f3 : (x: string) => Object
+>f2 : (x: Object) => string
+>f3 : (x: string) => Object
+
+f2 = f4;  // Error
+>f2 = f4 : (x: string) => string
+>f2 : (x: Object) => string
+>f4 : (x: string) => string
+
+f3 = f1;  // Ok
+>f3 = f1 : (x: Object) => Object
+>f3 : (x: string) => Object
+>f1 : (x: Object) => Object
+
+f3 = f2;  // Ok
+>f3 = f2 : (x: Object) => string
+>f3 : (x: string) => Object
+>f2 : (x: Object) => string
+
+f3 = f4;  // Ok
+>f3 = f4 : (x: string) => string
+>f3 : (x: string) => Object
+>f4 : (x: string) => string
+
+f4 = f1;  // Error
+>f4 = f1 : (x: Object) => Object
+>f4 : (x: string) => string
+>f1 : (x: Object) => Object
+
+f4 = f2;  // Ok
+>f4 = f2 : (x: Object) => string
+>f4 : (x: string) => string
+>f2 : (x: Object) => string
+
+f4 = f3;  // Error
+>f4 = f3 : (x: string) => Object
+>f4 : (x: string) => string
+>f3 : (x: string) => Object
+
+type Func<T, U> = (x: T) => U;
+>Func : (x: T) => U
+>T : T
+>U : U
+>x : T
+>T : T
+>U : U
+
+declare let g1: Func<Object, Object>;
+>g1 : (x: Object) => Object
+>Func : (x: T) => U
+>Object : Object
+>Object : Object
+
+declare let g2: Func<Object, string>;
+>g2 : (x: Object) => string
+>Func : (x: T) => U
+>Object : Object
+
+declare let g3: Func<string, Object>;
+>g3 : (x: string) => Object
+>Func : (x: T) => U
+>Object : Object
+
+declare let g4: Func<string, string>;
+>g4 : (x: string) => string
+>Func : (x: T) => U
+
+g1 = g2;  // Ok
+>g1 = g2 : (x: Object) => string
+>g1 : (x: Object) => Object
+>g2 : (x: Object) => string
+
+g1 = g3;  // Error
+>g1 = g3 : (x: string) => Object
+>g1 : (x: Object) => Object
+>g3 : (x: string) => Object
+
+g1 = g4;  // Error
+>g1 = g4 : (x: string) => string
+>g1 : (x: Object) => Object
+>g4 : (x: string) => string
+
+g2 = g1;  // Error
+>g2 = g1 : (x: Object) => Object
+>g2 : (x: Object) => string
+>g1 : (x: Object) => Object
+
+g2 = g3;  // Error
+>g2 = g3 : (x: string) => Object
+>g2 : (x: Object) => string
+>g3 : (x: string) => Object
+
+g2 = g4;  // Error
+>g2 = g4 : (x: string) => string
+>g2 : (x: Object) => string
+>g4 : (x: string) => string
+
+g3 = g1;  // Ok
+>g3 = g1 : (x: Object) => Object
+>g3 : (x: string) => Object
+>g1 : (x: Object) => Object
+
+g3 = g2;  // Ok
+>g3 = g2 : (x: Object) => string
+>g3 : (x: string) => Object
+>g2 : (x: Object) => string
+
+g3 = g4;  // Ok
+>g3 = g4 : (x: string) => string
+>g3 : (x: string) => Object
+>g4 : (x: string) => string
+
+g4 = g1;  // Error
+>g4 = g1 : (x: Object) => Object
+>g4 : (x: string) => string
+>g1 : (x: Object) => Object
+
+g4 = g2;  // Ok
+>g4 = g2 : (x: Object) => string
+>g4 : (x: string) => string
+>g2 : (x: Object) => string
+
+g4 = g3;  // Error
+>g4 = g3 : (x: string) => Object
+>g4 : (x: string) => string
+>g3 : (x: string) => Object
+
+declare let h1: Func<Func<Object, void>, Object>;
+>h1 : (x: Func) => Object
+>Func : (x: T) => U
+>Func : (x: T) => U
+>Object : Object
+>Object : Object
+
+declare let h2: Func<Func<Object, void>, string>;
+>h2 : (x: Func) => string
+>Func : (x: T) => U
+>Func : (x: T) => U
+>Object : Object
+
+declare let h3: Func<Func<string, void>, Object>;
+>h3 : (x: Func) => Object
+>Func : (x: T) => U
+>Func : (x: T) => U
+>Object : Object
+
+declare let h4: Func<Func<string, void>, string>;
+>h4 : (x: Func) => string
+>Func : (x: T) => U
+>Func : (x: T) => U
+
+h1 = h2;  // Ok
+>h1 = h2 : (x: Func) => string
+>h1 : (x: Func) => Object
+>h2 : (x: Func) => string
+
+h1 = h3;  // Ok
+>h1 = h3 : (x: Func) => Object
+>h1 : (x: Func) => Object
+>h3 : (x: Func) => Object
+
+h1 = h4;  // Ok
+>h1 = h4 : (x: Func) => string
+>h1 : (x: Func) => Object
+>h4 : (x: Func) => string
+
+h2 = h1;  // Error
+>h2 = h1 : (x: Func) => Object
+>h2 : (x: Func) => string
+>h1 : (x: Func) => Object
+
+h2 = h3;  // Error
+>h2 = h3 : (x: Func) => Object
+>h2 : (x: Func) => string
+>h3 : (x: Func) => Object
+
+h2 = h4;  // Ok
+>h2 = h4 : (x: Func) => string
+>h2 : (x: Func) => string
+>h4 : (x: Func) => string
+
+h3 = h1;  // Error
+>h3 = h1 : (x: Func) => Object
+>h3 : (x: Func) => Object
+>h1 : (x: Func) => Object
+
+h3 = h2;  // Error
+>h3 = h2 : (x: Func) => string
+>h3 : (x: Func) => Object
+>h2 : (x: Func) => string
+
+h3 = h4;  // Ok
+>h3 = h4 : (x: Func) => string
+>h3 : (x: Func) => Object
+>h4 : (x: Func) => string
+
+h4 = h1;  // Error
+>h4 = h1 : (x: Func) => Object
+>h4 : (x: Func) => string
+>h1 : (x: Func) => Object
+
+h4 = h2;  // Error
+>h4 = h2 : (x: Func) => string
+>h4 : (x: Func) => string
+>h2 : (x: Func) => string
+
+h4 = h3;  // Error
+>h4 = h3 : (x: Func) => Object
+>h4 : (x: Func) => string
+>h3 : (x: Func) => Object
+
+declare let i1: Func<Object, Func<Object, void>>;
+>i1 : (x: Object) => Func
+>Func : (x: T) => U
+>Object : Object
+>Func : (x: T) => U
+>Object : Object
+
+declare let i2: Func<Object, Func<string, void>>;
+>i2 : (x: Object) => Func
+>Func : (x: T) => U
+>Object : Object
+>Func : (x: T) => U
+
+declare let i3: Func<string, Func<Object, void>>;
+>i3 : (x: string) => Func
+>Func : (x: T) => U
+>Func : (x: T) => U
+>Object : Object
+
+declare let i4: Func<string, Func<string, void>>;
+>i4 : (x: string) => Func
+>Func : (x: T) => U
+>Func : (x: T) => U
+
+i1 = i2;  // Error
+>i1 = i2 : (x: Object) => Func
+>i1 : (x: Object) => Func
+>i2 : (x: Object) => Func
+
+i1 = i3;  // Error
+>i1 = i3 : (x: string) => Func
+>i1 : (x: Object) => Func
+>i3 : (x: string) => Func
+
+i1 = i4;  // Error
+>i1 = i4 : (x: string) => Func
+>i1 : (x: Object) => Func
+>i4 : (x: string) => Func
+
+i2 = i1;  // Ok
+>i2 = i1 : (x: Object) => Func
+>i2 : (x: Object) => Func
+>i1 : (x: Object) => Func
+
+i2 = i3;  // Error
+>i2 = i3 : (x: string) => Func
+>i2 : (x: Object) => Func
+>i3 : (x: string) => Func
+
+i2 = i4;  // Error
+>i2 = i4 : (x: string) => Func
+>i2 : (x: Object) => Func
+>i4 : (x: string) => Func
+
+i3 = i1;  // Ok
+>i3 = i1 : (x: Object) => Func
+>i3 : (x: string) => Func
+>i1 : (x: Object) => Func
+
+i3 = i2;  // Error
+>i3 = i2 : (x: Object) => Func
+>i3 : (x: string) => Func
+>i2 : (x: Object) => Func
+
+i3 = i4;  // Error
+>i3 = i4 : (x: string) => Func
+>i3 : (x: string) => Func
+>i4 : (x: string) => Func
+
+i4 = i1;  // Ok
+>i4 = i1 : (x: Object) => Func
+>i4 : (x: string) => Func
+>i1 : (x: Object) => Func
+
+i4 = i2;  // Ok
+>i4 = i2 : (x: Object) => Func
+>i4 : (x: string) => Func
+>i2 : (x: Object) => Func
+
+i4 = i3;  // Ok
+>i4 = i3 : (x: string) => Func
+>i4 : (x: string) => Func
+>i3 : (x: string) => Func
+
+interface Animal { animal: void }
+>Animal : Animal
+>animal : void
+
+interface Dog extends Animal { dog: void }
+>Dog : Dog
+>Animal : Animal
+>dog : void
+
+interface Cat extends Animal { cat: void }
+>Cat : Cat
+>Animal : Animal
+>cat : void
+
+interface Comparer1<T> {
+>Comparer1 : Comparer1<T>
+>T : T
+
+    compare(a: T, b: T): number;
+>compare : (a: T, b: T) => number
+>a : T
+>T : T
+>b : T
+>T : T
+}
+
+declare let animalComparer1: Comparer1<Animal>;
+>animalComparer1 : Comparer1<Animal>
+>Comparer1 : Comparer1<T>
+>Animal : Animal
+
+declare let dogComparer1: Comparer1<Dog>;
+>dogComparer1 : Comparer1<Dog>
+>Comparer1 : Comparer1<T>
+>Dog : Dog
+
+animalComparer1 = dogComparer1;  // Ok
+>animalComparer1 = dogComparer1 : Comparer1<Dog>
+>animalComparer1 : Comparer1<Animal>
+>dogComparer1 : Comparer1<Dog>
+
+dogComparer1 = animalComparer1;  // Ok
+>dogComparer1 = animalComparer1 : Comparer1<Animal>
+>dogComparer1 : Comparer1<Dog>
+>animalComparer1 : Comparer1<Animal>
+
+interface Comparer2<T> {
+>Comparer2 : Comparer2<T>
+>T : T
+
+    compare: (a: T, b: T) => number;
+>compare : (a: T, b: T) => number
+>a : T
+>T : T
+>b : T
+>T : T
+}
+
+declare let animalComparer2: Comparer2<Animal>;
+>animalComparer2 : Comparer2<Animal>
+>Comparer2 : Comparer2<T>
+>Animal : Animal
+
+declare let dogComparer2: Comparer2<Dog>;
+>dogComparer2 : Comparer2<Dog>
+>Comparer2 : Comparer2<T>
+>Dog : Dog
+
+animalComparer2 = dogComparer2;  // Error
+>animalComparer2 = dogComparer2 : Comparer2<Dog>
+>animalComparer2 : Comparer2<Animal>
+>dogComparer2 : Comparer2<Dog>
+
+dogComparer2 = animalComparer2;  // Ok
+>dogComparer2 = animalComparer2 : Comparer2<Animal>
+>dogComparer2 : Comparer2<Dog>
+>animalComparer2 : Comparer2<Animal>
+