a4f9bf0fce
* Create type aliases for unresolved type symbols * Accept new baselines * Update fourslash tests * Unresolved import aliases create tagged unresolved symbols * Add comments * Accept new baselines * Add fourslash tests
101 lines
2.6 KiB
Plaintext
101 lines
2.6 KiB
Plaintext
=== /typeReference.ts ===
|
|
// Tests that types are marked as used, even if used in places that don't accept type arguments.
|
|
|
|
|
|
type N = number;
|
|
>N : Symbol(N, Decl(typeReference.ts, 0, 0))
|
|
|
|
type U = number;
|
|
>U : Symbol(U, Decl(typeReference.ts, 3, 16))
|
|
|
|
export type Z = U<N>;
|
|
>Z : Symbol(Z, Decl(typeReference.ts, 4, 16))
|
|
>U : Symbol(U, Decl(typeReference.ts, 3, 16))
|
|
>N : Symbol(N, Decl(typeReference.ts, 0, 0))
|
|
|
|
=== /classReference.ts ===
|
|
type N = number;
|
|
>N : Symbol(N, Decl(classReference.ts, 0, 0))
|
|
|
|
class C { }
|
|
>C : Symbol(C, Decl(classReference.ts, 0, 16))
|
|
|
|
// This uses getTypeFromClassOrInterfaceReference instead of getTypeFromTypeAliasReference.
|
|
export class D extends C<N> {}
|
|
>D : Symbol(D, Decl(classReference.ts, 1, 11))
|
|
>C : Symbol(C, Decl(classReference.ts, 0, 16))
|
|
>N : Symbol(N, Decl(classReference.ts, 0, 0))
|
|
|
|
=== /interface.ts ===
|
|
import { Foo } from "unknown";
|
|
>Foo : Symbol(Foo, Decl(interface.ts, 0, 8))
|
|
|
|
export interface I<T> { x: Foo<T>; }
|
|
>I : Symbol(I, Decl(interface.ts, 0, 30))
|
|
>T : Symbol(T, Decl(interface.ts, 1, 19))
|
|
>x : Symbol(I.x, Decl(interface.ts, 1, 23))
|
|
>Foo : Symbol(Foo, Decl(interface.ts, 0, 8))
|
|
>T : Symbol(T, Decl(interface.ts, 1, 19))
|
|
|
|
=== /call.ts ===
|
|
import { foo } from "unknown";
|
|
>foo : Symbol(foo, Decl(call.ts, 0, 8))
|
|
|
|
type T = number;
|
|
>T : Symbol(T, Decl(call.ts, 0, 30))
|
|
|
|
foo<T>();
|
|
>foo : Symbol(foo, Decl(call.ts, 0, 8))
|
|
>T : Symbol(T, Decl(call.ts, 0, 30))
|
|
|
|
=== /new.ts ===
|
|
import { Foo } from "unkown";
|
|
>Foo : Symbol(Foo, Decl(new.ts, 0, 8))
|
|
|
|
type T = number;
|
|
>T : Symbol(T, Decl(new.ts, 0, 29))
|
|
|
|
new Foo<T>();
|
|
>Foo : Symbol(Foo, Decl(new.ts, 0, 8))
|
|
>T : Symbol(T, Decl(new.ts, 0, 29))
|
|
|
|
=== /callAny.ts ===
|
|
declare var g: any;
|
|
>g : Symbol(g, Decl(callAny.ts, 0, 11))
|
|
|
|
type U = number;
|
|
>U : Symbol(U, Decl(callAny.ts, 0, 19))
|
|
|
|
g<U>();
|
|
>g : Symbol(g, Decl(callAny.ts, 0, 11))
|
|
>U : Symbol(U, Decl(callAny.ts, 0, 19))
|
|
|
|
g<InvalidReference>(); // Should get error for type argument
|
|
>g : Symbol(g, Decl(callAny.ts, 0, 11))
|
|
>InvalidReference : Symbol(InvalidReference)
|
|
|
|
=== /super.ts ===
|
|
import { A, B } from "unknown";
|
|
>A : Symbol(A, Decl(super.ts, 0, 8))
|
|
>B : Symbol(B, Decl(super.ts, 0, 11))
|
|
|
|
type T = number;
|
|
>T : Symbol(T, Decl(super.ts, 0, 31))
|
|
|
|
export class C extends A<B> {
|
|
>C : Symbol(C, Decl(super.ts, 2, 16))
|
|
>A : Symbol(A, Decl(super.ts, 0, 8))
|
|
>B : Symbol(B, Decl(super.ts, 0, 11))
|
|
|
|
m() {
|
|
>m : Symbol(C.m, Decl(super.ts, 4, 29))
|
|
|
|
super.m<T>(1);
|
|
>T : Symbol(T, Decl(super.ts, 0, 31))
|
|
|
|
super.m<InvalidReference>(); // Should get error for type argument
|
|
>InvalidReference : Symbol(InvalidReference)
|
|
}
|
|
}
|
|
|