microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-09 12:15:34 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

getTypeAtLocation supports parenthesised class exprs

Browse Source 
And accept baselines for later inspection.

One fourslash test changes, indicating that quick info relied on
getTypeAtLocation not returning anything for class expressions to
distinguish named from anonymous class expressions. This predicate will
have to be improved.
This commit is contained in:
Nathan Shively-Sanders 2022-10-03 09:08:07 -07:00
parent 5cd49f6cbc
commit 06f73dde70
272 changed files with 767 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/compiler/checker.ts
View File

@ -43099,6 +43099,8 @@ namespace ts {
case SyntaxKind.EqualsGreaterThanToken:
case SyntaxKind.ClassKeyword:
return getSymbolOfNode(node.parent);
case SyntaxKind.ClassExpression:
return node.symbol;
case SyntaxKind.ImportType:
return isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : undefined;
@ -43110,6 +43112,8 @@ namespace ts {
return isMetaProperty(node.parent) ? checkMetaPropertyKeyword(node.parent).symbol : undefined;
case SyntaxKind.MetaProperty:
return checkExpression(node as Expression).symbol;
case SyntaxKind.ParenthesizedExpression:
return getSymbolAtLocation((node as ParenthesizedExpression).expression, ignoreErrors);
default:
return undefined;

1
tests/baselines/reference/YieldExpression19_es6.symbols
View File

@ -9,6 +9,7 @@ function*foo() {
>quux : Symbol(quux, Decl(YieldExpression19_es6.ts, 1, 18))
yield(foo);
>(foo) : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0))
>foo : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0))
}
}

1
tests/baselines/reference/YieldExpression8_es6.symbols
View File

@ -6,5 +6,6 @@ function* foo() {
>foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11))
yield(foo);
>(foo) : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11))
>foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11))
}

1
tests/baselines/reference/accessorsOverrideProperty8.symbols
View File

@ -60,6 +60,7 @@ const Base = classWithProperties({
>y : Symbol(y, Decl(accessorsOverrideProperty8.ts, 14, 42))
}, class Base {
>class Base {} : Symbol(Base, Decl(accessorsOverrideProperty8.ts, 16, 2))
>Base : Symbol(Base, Decl(accessorsOverrideProperty8.ts, 16, 2))
});

1
tests/baselines/reference/ambientEnumDeclaration1.symbols
View File

@ -16,6 +16,7 @@ declare enum E {
d = (c) + 1,
>d : Symbol(E.d, Decl(ambientEnumDeclaration1.ts, 5, 10))
>(c) : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15))
>c : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15))
e = 10 << 2 * 8,

1
tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.symbols
View File

@ -28,6 +28,7 @@ export function Configurable<T extends Constructor<{}>>(base: T): T {
>T : Symbol(T, Decl(Configurable.ts, 3, 29))
return class extends base {
>class extends base { constructor(...args: any[]) { super(...args); } } : Symbol((Anonymous class), Decl(Configurable.ts, 4, 10))
>base : Symbol(base, Decl(Configurable.ts, 3, 56))
constructor(...args: any[]) {

2
tests/baselines/reference/anonClassDeclarationEmitIsAnon.symbols
View File

@ -4,6 +4,7 @@ export function wrapClass(param: any) {
>param : Symbol(param, Decl(wrapClass.ts, 0, 26))
return class Wrapped {
>class Wrapped { foo() { return param; } } : Symbol(Wrapped, Decl(wrapClass.ts, 1, 10))
>Wrapped : Symbol(Wrapped, Decl(wrapClass.ts, 1, 10))
foo() {
@ -29,6 +30,7 @@ export function Timestamped<TBase extends Constructor>(Base: TBase) {
>TBase : Symbol(TBase, Decl(wrapClass.ts, 10, 28))
return class extends Base {
>class extends Base { timestamp = Date.now(); } : Symbol((Anonymous class), Decl(wrapClass.ts, 11, 10))
>Base : Symbol(Base, Decl(wrapClass.ts, 10, 55))
timestamp = Date.now();

1
tests/baselines/reference/anonymousClassDeclarationDoesntPrintWithReadonly.symbols
View File

@ -10,5 +10,6 @@ export function y() {
>y : Symbol(y, Decl(anonymousClassDeclarationDoesntPrintWithReadonly.ts, 2, 1))
return class extends X { }
>class extends X { } : Symbol((Anonymous class), Decl(anonymousClassDeclarationDoesntPrintWithReadonly.ts, 5, 10))
>X : Symbol(X, Decl(anonymousClassDeclarationDoesntPrintWithReadonly.ts, 0, 0))
}

1
tests/baselines/reference/anonymousClassExpression1.symbols
View File

@ -3,4 +3,5 @@ function f() {
>f : Symbol(f, Decl(anonymousClassExpression1.ts, 0, 0))
return typeof class {} === "function";
>class {} : Symbol((Anonymous class), Decl(anonymousClassExpression1.ts, 1, 17))
}

5
tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
View File

@ -3,6 +3,7 @@ function A() {
>A : Symbol(A, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 0, 0))
return class T {
>class T { a = arguments } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 1, 8))
>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 1, 8))
a = arguments
@ -15,6 +16,7 @@ function A1() {
>A1 : Symbol(A1, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 4, 1))
return new class T {
>class T { a = arguments } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 7, 12))
>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 7, 12))
a = arguments
@ -27,6 +29,7 @@ function B() {
>B : Symbol(B, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 10, 1))
return class T {
>class T { a = { b: arguments } } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 13, 8))
>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 13, 8))
a = { b: arguments }
@ -40,6 +43,7 @@ function B1() {
>B1 : Symbol(B1, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 16, 1))
return new class T {
>class T { a = { b: arguments } } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 19, 12))
>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 19, 12))
a = { b: arguments }
@ -53,6 +57,7 @@ function C() {
>C : Symbol(C, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 22, 1))
return class T {
>class T { a = function () { arguments } } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 25, 8))
>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 25, 8))
a = function () { arguments }

1
tests/baselines/reference/assertionTypePredicates2.symbols
View File

@ -17,6 +17,7 @@ const foo = (a) => {
if (/** @type { B } */ (a).y !== 0) throw TypeError();
>(a).y : Symbol(y, Decl(assertionTypePredicates2.js, 5, 19))
>(a) : Symbol(a, Decl(assertionTypePredicates2.js, 12, 13))
>a : Symbol(a, Decl(assertionTypePredicates2.js, 12, 13))
>y : Symbol(y, Decl(assertionTypePredicates2.js, 5, 19))
>TypeError : Symbol(TypeError, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))

2
tests/baselines/reference/assignParameterPropertyToPropertyDeclarationESNext.symbols
View File

@ -109,6 +109,7 @@ class F {
Inner = class extends F {
>Inner : Symbol(F.Inner, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 29, 9))
>class extends F { p2 = this.p1 } : Symbol((Anonymous class), Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 30, 11))
>F : Symbol(F, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 27, 1))
p2 = this.p1
@ -125,6 +126,7 @@ class G {
Inner = class extends G {
>Inner : Symbol(G.Inner, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 35, 9))
>class extends G { p2 = this.p1 } : Symbol((Anonymous class), Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 36, 11))
>G : Symbol(G, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 34, 1))
p2 = this.p1

3
tests/baselines/reference/assignmentLHSIsReference.symbols
View File

@ -37,6 +37,7 @@ x3['a'] = value;
// parentheses, the contained expression is reference
(x1) = value;
>(x1) : Symbol(x1, Decl(assignmentLHSIsReference.ts, 3, 3))
>x1 : Symbol(x1, Decl(assignmentLHSIsReference.ts, 3, 3))
>value : Symbol(value, Decl(assignmentLHSIsReference.ts, 0, 3))
@ -45,11 +46,13 @@ function fn2(x4: number) {
>x4 : Symbol(x4, Decl(assignmentLHSIsReference.ts, 18, 13))
(x4) = value;
>(x4) : Symbol(x4, Decl(assignmentLHSIsReference.ts, 18, 13))
>x4 : Symbol(x4, Decl(assignmentLHSIsReference.ts, 18, 13))
>value : Symbol(value, Decl(assignmentLHSIsReference.ts, 0, 3))
}
(x3.a) = value;
>(x3.a) : Symbol(a, Decl(assignmentLHSIsReference.ts, 11, 9))
>x3.a : Symbol(a, Decl(assignmentLHSIsReference.ts, 11, 9))
>x3 : Symbol(x3, Decl(assignmentLHSIsReference.ts, 11, 3))
>a : Symbol(a, Decl(assignmentLHSIsReference.ts, 11, 9))

5
tests/baselines/reference/assignmentLHSIsValue.symbols
View File

@ -117,22 +117,27 @@ foo() = value;
// parentheses, the containted expression is value
(this) = value;
>(this) : Symbol(globalThis)
>this : Symbol(globalThis)
>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
(M) = value;
>(M) : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13))
>M : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13))
>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
(C) = value;
>(C) : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15))
>C : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15))
>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
(E) = value;
>(E) : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10))
>E : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10))
>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
(foo) = value;
>(foo) : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1))
>foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1))
>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))

22
tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols
View File

@ -6,12 +6,14 @@ x = 3; // OK
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
(x) = 3; // OK
>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
x = ''; // Error
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
(x) = ''; // Error
>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
module M {
@ -27,10 +29,12 @@ M.y = 3; // OK
(M).y = 3; // OK
>(M).y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
>(M) : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
(M.y) = 3; // OK
>(M.y) : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
>M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
@ -42,10 +46,12 @@ M.y = ''; // Error
(M).y = ''; // Error
>(M).y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
>(M) : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
(M.y) = ''; // Error
>(M.y) : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
>M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
@ -55,6 +61,7 @@ M = { y: 3 }; // Error
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 16, 5))
(M) = { y: 3 }; // Error
>(M) : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 7))
@ -80,11 +87,13 @@ M2.M3 = { x: 3 }; // OK
(M2).M3 = { x: 3 }; // OK
>(M2).M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>(M2) : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 27, 11))
(M2.M3) = { x: 3 }; // OK
>(M2.M3) : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
@ -98,11 +107,13 @@ M2.M3 = { x: '' }; // Error
(M2).M3 = { x: '' }; // Error
>(M2).M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>(M2) : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 31, 11))
(M2.M3) = { x: '' }; // Error
>(M2.M3) : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
@ -116,6 +127,7 @@ fn = () => 3; // Bug 823548: Should be error (fn is not a reference)
>fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20))
(fn) = () => 3; // Should be error
>(fn) : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20))
>fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20))
function fn2(x: number, y: { t: number }) {
@ -128,30 +140,36 @@ function fn2(x: number, y: { t: number }) {
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
(x) = 3; // OK
>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
x = ''; // Error
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
(x) = ''; // Error
>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
(y).t = 3; // OK
>(y).t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
(y.t) = 3; // OK
>(y.t) : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
>y.t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
(y).t = ''; // Error
>(y).t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
(y.t) = ''; // Error
>(y.t) : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
>y.t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
@ -161,6 +179,7 @@ function fn2(x: number, y: { t: number }) {
>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
(y)['t'] = 3; // OK
>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
@ -173,6 +192,7 @@ function fn2(x: number, y: { t: number }) {
>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
(y)['t'] = ''; // Error
>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
@ -192,6 +212,7 @@ E = undefined; // Error
>undefined : Symbol(undefined)
(E) = undefined; // Error
>(E) : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1))
>E : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1))
>undefined : Symbol(undefined)
@ -205,6 +226,7 @@ C = undefined; // Error
>undefined : Symbol(undefined)
(C) = undefined; // Error
>(C) : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16))
>C : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16))
>undefined : Symbol(undefined)

2
tests/baselines/reference/asyncAwaitNestedClasses_es5.symbols
View File

@ -5,6 +5,7 @@ class A {
static B = class B {
>B : Symbol(A.B, Decl(asyncAwaitNestedClasses_es5.ts, 1, 9))
>class B { static func2(): Promise<void> { return new Promise((resolve) => { resolve(null); }); } static C = class C { static async func() { await B.func2(); } } } : Symbol(B, Decl(asyncAwaitNestedClasses_es5.ts, 2, 14))
>B : Symbol(B, Decl(asyncAwaitNestedClasses_es5.ts, 2, 14))
static func2(): Promise<void> {
@ -18,6 +19,7 @@ class A {
}
static C = class C {
>C : Symbol(B.C, Decl(asyncAwaitNestedClasses_es5.ts, 5, 9))
>class C { static async func() { await B.func2(); } } : Symbol(C, Decl(asyncAwaitNestedClasses_es5.ts, 6, 18))
>C : Symbol(C, Decl(asyncAwaitNestedClasses_es5.ts, 6, 18))
static async func() {

2
tests/baselines/reference/awaitInClassInAsyncFunction.symbols
View File

@ -11,6 +11,8 @@ async function foo() {
>foo : Symbol(foo, Decl(awaitInClassInAsyncFunction.ts, 4, 1))
return new class {
>class { baz = await bar(); } : Symbol((Anonymous class), Decl(awaitInClassInAsyncFunction.ts, 7, 14))
baz = await bar();
>baz : Symbol((Anonymous class).baz, Decl(awaitInClassInAsyncFunction.ts, 7, 22))
>bar : Symbol(bar, Decl(awaitInClassInAsyncFunction.ts, 0, 0))

2
tests/baselines/reference/baseConstraintOfDecorator.symbols
View File

@ -10,6 +10,7 @@ export function classExtender<TFunction>(superClass: TFunction, _instanceModifie
>TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 0, 30))
return class decoratorFunc extends superClass {
>class decoratorFunc extends superClass { constructor(...args: any[]) { super(...args); _instanceModifier(this, args); } } : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 1, 10))
>decoratorFunc : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 1, 10))
>superClass : Symbol(superClass, Decl(baseConstraintOfDecorator.ts, 0, 41))
@ -44,6 +45,7 @@ export function classExtender2<TFunction extends new (...args: string[]) => MyCl
>TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 10, 31))
return class decoratorFunc extends superClass {
>class decoratorFunc extends superClass { constructor(...args: any[]) { super(...args); _instanceModifier(this, args); } } : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 11, 10))
>decoratorFunc : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 11, 10))
>superClass : Symbol(superClass, Decl(baseConstraintOfDecorator.ts, 10, 85))

5
tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols
View File

@ -51,6 +51,7 @@ function foo4() {
let y = class {
>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 7))
>class { m() { return x; } } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 11))
m() { return x; }
>m : Symbol(y.m, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 19))
@ -105,6 +106,7 @@ function foo8() {
let y = class {
>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 7))
>class { a = x; } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 11))
a = x;
>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 19))
@ -119,6 +121,7 @@ function foo9() {
let y = class {
>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 7))
>class { static a = x; } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 11))
static a = x;
>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 19))
@ -150,6 +153,7 @@ function foo11() {
let y = class {
>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 11))
>class { static a = x; } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 15))
static a = x;
>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 23))
@ -168,6 +172,7 @@ function foo12() {
let y = class {
>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 11))
>class { a; constructor() { this.a = x; } } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 15))
a;
>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 23))

9
tests/baselines/reference/callWithSpread.symbols
View File

@ -86,24 +86,29 @@ obj.foo(1, 2, ...a).foo(1, 2, ...a, "abc");
>a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
(obj.foo)(1, 2, "abc");
>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
(obj.foo)(1, 2, ...a);
>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
(obj.foo)(1, 2, ...a, "abc");
>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
((obj.foo)(1, 2, ...a).foo)(1, 2, "abc");
>((obj.foo)(1, 2, ...a).foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>(obj.foo)(1, 2, ...a).foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
@ -111,7 +116,9 @@ obj.foo(1, 2, ...a).foo(1, 2, ...a, "abc");
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
((obj.foo)(1, 2, ...a).foo)(1, 2, ...a);
>((obj.foo)(1, 2, ...a).foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>(obj.foo)(1, 2, ...a).foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
@ -120,7 +127,9 @@ obj.foo(1, 2, ...a).foo(1, 2, ...a, "abc");
>a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
((obj.foo)(1, 2, ...a).foo)(1, 2, ...a, "abc");
>((obj.foo)(1, 2, ...a).foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>(obj.foo)(1, 2, ...a).foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))

3
tests/baselines/reference/callWithSpreadES6.symbols
View File

@ -59,17 +59,20 @@ obj.foo(1, 2, ...a, "abc");
>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3))
(obj.foo)(1, 2, "abc");
>(obj.foo) : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
(obj.foo)(1, 2, ...a);
>(obj.foo) : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3))
(obj.foo)(1, 2, ...a, "abc");
>(obj.foo) : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
>obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3))
>foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))

1
tests/baselines/reference/capturedParametersInInitializers1.symbols
View File

@ -3,6 +3,7 @@
function foo1(y = class {c = x}, x = 1) {
>foo1 : Symbol(foo1, Decl(capturedParametersInInitializers1.ts, 0, 0))
>y : Symbol(y, Decl(capturedParametersInInitializers1.ts, 1, 14))
>class {c = x} : Symbol((Anonymous class), Decl(capturedParametersInInitializers1.ts, 1, 17))
>c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers1.ts, 1, 25))
>x : Symbol(x, Decl(capturedParametersInInitializers1.ts, 1, 32))
>x : Symbol(x, Decl(capturedParametersInInitializers1.ts, 1, 32))

2
tests/baselines/reference/capturedParametersInInitializers2.symbols
View File

@ -4,6 +4,7 @@ function foo(
y = class {
>y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 0, 13))
>class { static c = x; get [x]() {return x;} constructor() { x; } [z]() { return z; } } : Symbol((Anonymous class), Decl(capturedParametersInInitializers2.ts, 1, 7))
static c = x;
>c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers2.ts, 1, 15))
@ -38,6 +39,7 @@ function foo(
function foo2(y = class {[x] = x}, x = 1) {
>foo2 : Symbol(foo2, Decl(capturedParametersInInitializers2.ts, 11, 1))
>y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 12, 14))
>class {[x] = x} : Symbol((Anonymous class), Decl(capturedParametersInInitializers2.ts, 12, 17))
>[x] : Symbol((Anonymous class)[x], Decl(capturedParametersInInitializers2.ts, 12, 25))
>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 12, 34))
>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 12, 34))

1
tests/baselines/reference/castExpressionParentheses.symbols
View File

@ -79,6 +79,7 @@ new (<any>A());
// nested parenthesized expression, should keep one pair of parenthese
(<any>(A))
>(A) : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11))
>A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11))

1
tests/baselines/reference/checkSpecialPropertyAssignments.symbols
View File

@ -6,6 +6,7 @@ A.B = class {
>A.B : Symbol(A.B, Decl(bug24252.js, 0, 11))
>A : Symbol(A, Decl(bug24252.js, 0, 3), Decl(bug24252.js, 0, 11))
>B : Symbol(A.B, Decl(bug24252.js, 0, 11))
>class { m() { /** @type {string[]} */ var x = []; /** @type {number[]} */ var y; y = x; }} : Symbol(B, Decl(bug24252.js, 1, 5))
m() {
>m : Symbol(B.m, Decl(bug24252.js, 1, 13))

1
tests/baselines/reference/classBlockScoping.symbols
View File

@ -11,6 +11,7 @@ function f(b: boolean) {
Foo = class Foo {
>Foo : Symbol(Foo, Decl(classBlockScoping.ts, 1, 5))
>class Foo { static y = new Foo(); static x() { new Foo(); } m() { new Foo(); } } : Symbol(Foo, Decl(classBlockScoping.ts, 3, 9))
>Foo : Symbol(Foo, Decl(classBlockScoping.ts, 3, 9))
static y = new Foo();

1
tests/baselines/reference/classDeclaredBeforeClassFactory.symbols
View File

@ -8,6 +8,7 @@ function makeBaseClass() {
>makeBaseClass : Symbol(makeBaseClass, Decl(classDeclaredBeforeClassFactory.ts, 1, 40))
return class Base {};
>class Base {} : Symbol(Base, Decl(classDeclaredBeforeClassFactory.ts, 4, 10))
>Base : Symbol(Base, Decl(classDeclaredBeforeClassFactory.ts, 4, 10))
}

3
tests/baselines/reference/classExpression.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/conformance/classes/classExpression.ts ===
var x = class C {
>x : Symbol(x, Decl(classExpression.ts, 0, 3))
>class C {} : Symbol(C, Decl(classExpression.ts, 0, 7))
>C : Symbol(C, Decl(classExpression.ts, 0, 7))
}
@ -9,6 +10,7 @@ var y = {
foo: class C2 {
>foo : Symbol(foo, Decl(classExpression.ts, 3, 9))
>class C2 { } : Symbol(C2, Decl(classExpression.ts, 4, 8))
>C2 : Symbol(C2, Decl(classExpression.ts, 4, 8))
}
}
@ -18,6 +20,7 @@ module M {
var z = class C4 {
>z : Symbol(z, Decl(classExpression.ts, 9, 7))
>class C4 { } : Symbol(C4, Decl(classExpression.ts, 9, 11))
>C4 : Symbol(C4, Decl(classExpression.ts, 9, 11))
}
}

1
tests/baselines/reference/classExpression1.symbols
View File

@ -1,5 +1,6 @@
=== tests/cases/conformance/classes/classExpressions/classExpression1.ts ===
var v = class C {};
>v : Symbol(v, Decl(classExpression1.ts, 0, 3))
>class C {} : Symbol(C, Decl(classExpression1.ts, 0, 7))
>C : Symbol(C, Decl(classExpression1.ts, 0, 7))

1
tests/baselines/reference/classExpression2.symbols
View File

@ -4,6 +4,7 @@ class D { }
var v = class C extends D {};
>v : Symbol(v, Decl(classExpression2.ts, 1, 3))
>class C extends D {} : Symbol(C, Decl(classExpression2.ts, 1, 7))
>C : Symbol(C, Decl(classExpression2.ts, 1, 7))
>D : Symbol(D, Decl(classExpression2.ts, 0, 0))

3
tests/baselines/reference/classExpression3.symbols
View File

@ -1,6 +1,9 @@
=== tests/cases/conformance/classes/classExpressions/classExpression3.ts ===
let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
>C : Symbol(C, Decl(classExpression3.ts, 0, 3))
>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol(C, Decl(classExpression3.ts, 0, 7))
>class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 21))
>class { a = 1 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 35))
>a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43))
>b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53))
>c : Symbol(C.c, Decl(classExpression3.ts, 0, 63))

1
tests/baselines/reference/classExpression4.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/conformance/classes/classExpressions/classExpression4.ts ===
let C = class {
>C : Symbol(C, Decl(classExpression4.ts, 0, 3))
>class { foo() { return new C(); }} : Symbol(C, Decl(classExpression4.ts, 0, 7))
foo() {
>foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15))

1
tests/baselines/reference/classExpression5.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/conformance/classes/classExpressions/classExpression5.ts ===
new class {
>new class { hi() { return "Hi!"; }}().hi : Symbol((Anonymous class).hi, Decl(classExpression5.ts, 0, 11))
>class { hi() { return "Hi!"; }} : Symbol((Anonymous class), Decl(classExpression5.ts, 0, 3))
hi() {
>hi : Symbol((Anonymous class).hi, Decl(classExpression5.ts, 0, 11))

1
tests/baselines/reference/classExpressionAssignment.symbols
View File

@ -10,4 +10,5 @@ interface A {
const A: {new(): A} = class {}
>A : Symbol(A, Decl(classExpressionAssignment.ts, 0, 0), Decl(classExpressionAssignment.ts, 5, 5))
>A : Symbol(A, Decl(classExpressionAssignment.ts, 0, 0), Decl(classExpressionAssignment.ts, 5, 5))
>class {} : Symbol(A, Decl(classExpressionAssignment.ts, 5, 21))

1
tests/baselines/reference/classExpressionES61.symbols
View File

@ -1,5 +1,6 @@
=== tests/cases/conformance/es6/classExpressions/classExpressionES61.ts ===
var v = class C {};
>v : Symbol(v, Decl(classExpressionES61.ts, 0, 3))
>class C {} : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
>C : Symbol(C, Decl(classExpressionES61.ts, 0, 7))

1
tests/baselines/reference/classExpressionES62.symbols
View File

@ -4,6 +4,7 @@ class D { }
var v = class C extends D {};
>v : Symbol(v, Decl(classExpressionES62.ts, 1, 3))
>class C extends D {} : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
>C : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
>D : Symbol(D, Decl(classExpressionES62.ts, 0, 0))

3
tests/baselines/reference/classExpressionES63.symbols
View File

@ -1,6 +1,9 @@
=== tests/cases/conformance/es6/classExpressions/classExpressionES63.ts ===
let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
>C : Symbol(C, Decl(classExpressionES63.ts, 0, 3))
>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol(C, Decl(classExpressionES63.ts, 0, 7))
>class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 21))
>class { a = 1 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 35))
>a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43))
>b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53))
>c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63))

1
tests/baselines/reference/classExpressionExtendingAbstractClass.symbols
View File

@ -8,6 +8,7 @@ abstract class A {
var C = class extends A { // no error reported!
>C : Symbol(C, Decl(classExpressionExtendingAbstractClass.ts, 4, 3))
>class extends A { // no error reported!} : Symbol(C, Decl(classExpressionExtendingAbstractClass.ts, 4, 7))
>A : Symbol(A, Decl(classExpressionExtendingAbstractClass.ts, 0, 0))
};

1
tests/baselines/reference/classExpressionInClassStaticDeclarations.symbols
View File

@ -4,5 +4,6 @@ class C {
static D = class extends C {};
>D : Symbol(C.D, Decl(classExpressionInClassStaticDeclarations.ts, 0, 9))
>class extends C {} : Symbol((Anonymous class), Decl(classExpressionInClassStaticDeclarations.ts, 1, 14))
>C : Symbol(C, Decl(classExpressionInClassStaticDeclarations.ts, 0, 0))
}

1
tests/baselines/reference/classExpressionLoop.symbols
View File

@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>arr : Symbol(arr, Decl(classExpressionLoop.ts, 0, 3))
>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>class C { prop = i; } : Symbol(C, Decl(classExpressionLoop.ts, 2, 13))
>C : Symbol(C, Decl(classExpressionLoop.ts, 2, 13))
prop = i;

4
tests/baselines/reference/classExpressionNames.symbols
View File

@ -4,6 +4,7 @@ var o = {
C: class {
>C : Symbol(C, Decl(ts.ts, 0, 9))
>class { } : Symbol(C, Decl(ts.ts, 1, 6))
}
}
var oc = new o.C()
@ -14,6 +15,7 @@ var oc = new o.C()
var V = class {
>V : Symbol(V, Decl(ts.ts, 6, 3))
>class {} : Symbol(V, Decl(ts.ts, 6, 7))
}
var v = new V()
>v : Symbol(v, Decl(ts.ts, 8, 3))
@ -24,6 +26,7 @@ var A;
A = class {
>A : Symbol(A, Decl(ts.ts, 10, 3))
>class {} : Symbol(A, Decl(ts.ts, 11, 3))
}
var a = new A()
>a : Symbol(a, Decl(ts.ts, 13, 3))
@ -32,6 +35,7 @@ var a = new A()
const {
B = class { }
>B : Symbol(B, Decl(ts.ts, 15, 7))
>class { } : Symbol(B, Decl(ts.ts, 16, 7))
} = ({ B: undefined });
>B : Symbol(B, Decl(ts.ts, 17, 6))

1
tests/baselines/reference/classExpressionTest2.symbols
View File

@ -4,6 +4,7 @@ function M() {
var m = class C<X> {
>m : Symbol(m, Decl(classExpressionTest2.ts, 1, 7))
>class C<X> { f<T>() { var t: T; var x: X; return { t, x }; } } : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
>C : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
>X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20))

1
tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
View File

@ -9,6 +9,7 @@ namespace C {
var x = class C {
>x : Symbol(x, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 3))
>class C { prop: C.type;} : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
>C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
prop: C.type;

1
tests/baselines/reference/classExpressionWithStaticProperties1.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/classExpressionWithStaticProperties1.ts ===
var v = class C {
>v : Symbol(v, Decl(classExpressionWithStaticProperties1.ts, 0, 3))
>class C { static a = 1; static b = 2; static c = C.a + C.b;} : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
>C : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
static a = 1;

1
tests/baselines/reference/classExpressionWithStaticProperties2.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/classExpressionWithStaticProperties2.ts ===
var v = class C {
>v : Symbol(v, Decl(classExpressionWithStaticProperties2.ts, 0, 3))
>class C { static a = 1; static b static c = { x: "hi" } static d = C.c.x + " world"; } : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
>C : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
static a = 1;

1
tests/baselines/reference/classExpressionWithStaticProperties3.symbols
View File

@ -15,6 +15,7 @@ for (let i = 0; i < 3; i++) {
>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5))
>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>class C { static x = i; static y = () => C.x * 2; } : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13))
>C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13))
static x = i;

1
tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts ===
var v = class C {
>v : Symbol(v, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 3))
>class C { static a = 1; static b = 2; static c = C.a + 3;} : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
static a = 1;

1
tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts ===
var v = class C {
>v : Symbol(v, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 3))
>class C { static a = 1; static b static c = { x: "hi" } static d = C.c.x + " world"; } : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
static a = 1;

1
tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
View File

@ -15,6 +15,7 @@ for (let i = 0; i < 3; i++) {
>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5))
>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>class C { static x = i; static y = () => C.x * 2; } : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13))
>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13))
static x = i;

2
tests/baselines/reference/classExpressionWithStaticPropertiesES64.symbols
View File

@ -1,4 +1,6 @@
=== tests/cases/compiler/classExpressionWithStaticPropertiesES64.ts ===
(class { static x = 0; });
>(class { static x = 0; }) : Symbol((Anonymous class), Decl(classExpressionWithStaticPropertiesES64.ts, 0, 1))
>class { static x = 0; } : Symbol((Anonymous class), Decl(classExpressionWithStaticPropertiesES64.ts, 0, 1))
>x : Symbol((Anonymous class).x, Decl(classExpressionWithStaticPropertiesES64.ts, 0, 8))

1
tests/baselines/reference/classExpressions.symbols
View File

@ -4,6 +4,7 @@ interface A {}
let x = class B implements A {
>x : Symbol(x, Decl(classExpressions.ts, 1, 3))
>class B implements A { prop: number; onStart(): void { } func = () => { }} : Symbol(B, Decl(classExpressions.ts, 1, 7))
>B : Symbol(B, Decl(classExpressions.ts, 1, 7))
>A : Symbol(A, Decl(classExpressions.ts, 0, 0))

3
tests/baselines/reference/classStaticBlock18(target=es2015).symbols
View File

@ -3,12 +3,15 @@ function foo () {
>foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
return class {
>class { static foo = 1; static { const c = class { static bar = 2; static { // do } } } } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
static foo = 1;
>foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
static {
const c = class {
>c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
>class { static bar = 2; static { // do } } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
static bar = 2;
>bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))

3
tests/baselines/reference/classStaticBlock18(target=es2022).symbols
View File

@ -3,12 +3,15 @@ function foo () {
>foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
return class {
>class { static foo = 1; static { const c = class { static bar = 2; static { // do } } } } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
static foo = 1;
>foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
static {
const c = class {
>c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
>class { static bar = 2; static { // do } } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
static bar = 2;
>bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))

3
tests/baselines/reference/classStaticBlock18(target=es5).symbols
View File

@ -3,12 +3,15 @@ function foo () {
>foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
return class {
>class { static foo = 1; static { const c = class { static bar = 2; static { // do } } } } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
static foo = 1;
>foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
static {
const c = class {
>c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
>class { static bar = 2; static { // do } } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
static bar = 2;
>bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))

3
tests/baselines/reference/classStaticBlock18(target=esnext).symbols
View File

@ -3,12 +3,15 @@ function foo () {
>foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
return class {
>class { static foo = 1; static { const c = class { static bar = 2; static { // do } } } } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
static foo = 1;
>foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
static {
const c = class {
>c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
>class { static bar = 2; static { // do } } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
static bar = 2;
>bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))

2
tests/baselines/reference/classStaticBlock22(target=es2022).symbols
View File

@ -49,6 +49,8 @@ class C {
}
static {
(class await { }); // legal, 'await' in class expression name not bound inside of static block
>(class await { }) : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
>class await { } : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
>await : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
}
static {

2
tests/baselines/reference/classStaticBlock22(target=esnext).symbols
View File

@ -49,6 +49,8 @@ class C {
}
static {
(class await { }); // legal, 'await' in class expression name not bound inside of static block
>(class await { }) : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
>class await { } : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
>await : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
}
static {

1
tests/baselines/reference/classStaticBlock27.symbols
View File

@ -2,6 +2,7 @@
// https://github.com/microsoft/TypeScript/issues/44872
void class Foo {
>class Foo { static prop = 1 static { console.log(Foo.prop); Foo.prop++; } static { console.log(Foo.prop); Foo.prop++; } static { console.log(Foo.prop); Foo.prop++; }} : Symbol(Foo, Decl(classStaticBlock27.ts, 2, 4))
>Foo : Symbol(Foo, Decl(classStaticBlock27.ts, 2, 4))
static prop = 1

2
tests/baselines/reference/classUsedBeforeInitializedVariables.symbols
View File

@ -93,6 +93,8 @@ class Test {
withinClassDeclarationExtension: any = (class extends this.withinClassDeclarationExtension { });
>withinClassDeclarationExtension : Symbol(Test.withinClassDeclarationExtension, Decl(classUsedBeforeInitializedVariables.ts, 32, 6))
>(class extends this.withinClassDeclarationExtension { }) : Symbol((Anonymous class), Decl(classUsedBeforeInitializedVariables.ts, 34, 44))
>class extends this.withinClassDeclarationExtension { } : Symbol((Anonymous class), Decl(classUsedBeforeInitializedVariables.ts, 34, 44))
>this.withinClassDeclarationExtension : Symbol(Test.withinClassDeclarationExtension, Decl(classUsedBeforeInitializedVariables.ts, 32, 6))
>this : Symbol(Test, Decl(classUsedBeforeInitializedVariables.ts, 0, 0))
>withinClassDeclarationExtension : Symbol(Test.withinClassDeclarationExtension, Decl(classUsedBeforeInitializedVariables.ts, 32, 6))

1
tests/baselines/reference/commonJSImportExportedClassExpression.symbols
View File

@ -20,6 +20,7 @@ exports.K = class K {
>exports.K : Symbol(K, Decl(mod1.js, 0, 0))
>exports : Symbol(K, Decl(mod1.js, 0, 0))
>K : Symbol(K, Decl(mod1.js, 0, 0))
>class K { values() { }} : Symbol(K, Decl(mod1.js, 0, 11))
>K : Symbol(K, Decl(mod1.js, 0, 11))
values() {

1
tests/baselines/reference/commonJSImportNestedClassTypeReference.symbols
View File

@ -23,6 +23,7 @@ NS.K =class {
>NS.K : Symbol(K, Decl(mod1.js, 0, 11))
>NS : Symbol(NS, Decl(mod1.js, 0, 3), Decl(mod1.js, 0, 11))
>K : Symbol(K, Decl(mod1.js, 0, 11))
>class { values() { return new NS.K() }} : Symbol(K, Decl(mod1.js, 1, 6))
values() {
>values : Symbol(K.values, Decl(mod1.js, 1, 13))

2
tests/baselines/reference/commonJsImportClassExpression.symbols
View File

@ -13,6 +13,8 @@ c.chunk;
=== tests/cases/compiler/mod1.ts ===
export = class {
>class { chunk = 1} : Symbol((Anonymous class), Decl(mod1.ts, 0, 8))
chunk = 1
>chunk : Symbol((Anonymous class).chunk, Decl(mod1.ts, 0, 16))
}

6
tests/baselines/reference/compoundAssignmentLHSIsReference.symbols
View File

@ -56,10 +56,12 @@ x3['a'] += value;
// parentheses, the contained expression is reference
(x1) *= value;
>(x1) : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
>x1 : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
>value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
(x1) += value;
>(x1) : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
>x1 : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
>value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
@ -68,21 +70,25 @@ function fn2(x4: number) {
>x4 : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
(x4) *= value;
>(x4) : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
>x4 : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
>value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
(x4) += value;
>(x4) : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
>x4 : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
>value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
}
(x3.a) *= value;
>(x3.a) : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
>x3.a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
>x3 : Symbol(x3, Decl(compoundAssignmentLHSIsReference.ts, 13, 3))
>a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
>value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
(x3.a) += value;
>(x3.a) : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
>x3.a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
>x3 : Symbol(x3, Decl(compoundAssignmentLHSIsReference.ts, 13, 3))
>a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))

10
tests/baselines/reference/compoundAssignmentLHSIsValue.symbols
View File

@ -218,42 +218,52 @@ foo() += value;
// parentheses, the containted expression is value
(this) *= value;
>(this) : Symbol(globalThis)
>this : Symbol(globalThis)
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(this) += value;
>(this) : Symbol(globalThis)
>this : Symbol(globalThis)
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(M) *= value;
>(M) : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
>M : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(M) += value;
>(M) : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
>M : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(C) *= value;
>(C) : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
>C : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(C) += value;
>(C) : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
>C : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(E) *= value;
>(E) : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
>E : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(E) += value;
>(E) : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
>E : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(foo) *= value;
>(foo) : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
>foo : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
(foo) += value;
>(foo) : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
>foo : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
>value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))

3
tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols
View File

@ -37,6 +37,7 @@ x3['a'] **= value;
// parentheses, the contained expression is reference
(x1) **= value;
>(x1) : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
@ -45,11 +46,13 @@ function fn2(x4: number) {
>x4 : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
(x4) **= value;
>(x4) : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
>x4 : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
}
(x3.a) **= value;
>(x3.a) : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
>x3.a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))

5
tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.symbols
View File

@ -136,22 +136,27 @@ foo() **= value;
// parentheses, the containted expression is value
(this) **= value;
>(this) : Symbol(globalThis)
>this : Symbol(globalThis)
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
(M) **= value;
>(M) : Symbol(M, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 20, 15))
>M : Symbol(M, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 20, 15))
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
(C) **= value;
>(C) : Symbol(C, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 15))
>C : Symbol(C, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 15))
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
(E) **= value;
>(E) : Symbol(E, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 26, 12))
>E : Symbol(E, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 26, 12))
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
(foo) **= value;
>(foo) : Symbol(foo, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 14, 1))
>foo : Symbol(foo, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 14, 1))
>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))

1
tests/baselines/reference/computedPropertyNames52(target=es2015).symbols
View File

@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
>array.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>array : Symbol(array, Decl(computedPropertyNames52.js, 0, 5))
>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>class C { [i] = () => C; static [i] = 100; } : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
>C : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
[i] = () => C;

1
tests/baselines/reference/computedPropertyNames52(target=es5).symbols
View File

@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
>array.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>array : Symbol(array, Decl(computedPropertyNames52.js, 0, 5))
>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
>class C { [i] = () => C; static [i] = 100; } : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
>C : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
[i] = () => C;

1
tests/baselines/reference/constAssertionOnEnum.symbols
View File

@ -60,6 +60,7 @@ export enum Foo { X }
(Foo).X as const;
>(Foo).X : Symbol(Foo.X, Decl(more.ts, 0, 17))
>(Foo) : Symbol(Foo, Decl(more.ts, 0, 0))
>Foo : Symbol(Foo, Decl(more.ts, 0, 0))
>X : Symbol(Foo.X, Decl(more.ts, 0, 17))
>const : Symbol(const)

3
tests/baselines/reference/constDeclarations-access2.symbols
View File

@ -52,6 +52,8 @@ x--;
>x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
++((x));
>((x)) : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
>(x) : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
>x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
// OK
@ -74,6 +76,7 @@ x;
>x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
(x);
>(x) : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
>x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
-x;

3
tests/baselines/reference/constDeclarations-access3.symbols
View File

@ -88,6 +88,8 @@ M.x--;
>x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
++((M.x));
>((M.x)) : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
>(M.x) : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
>M.x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
>M : Symbol(M, Decl(constDeclarations-access3.ts, 0, 0))
>x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
@ -124,6 +126,7 @@ M.x;
>x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
(M.x);
>(M.x) : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
>M.x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
>M : Symbol(M, Decl(constDeclarations-access3.ts, 0, 0))
>x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))

3
tests/baselines/reference/constDeclarations-access4.symbols
View File

@ -88,6 +88,8 @@ M.x--;
>x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
++((M.x));
>((M.x)) : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
>(M.x) : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
>M.x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
>M : Symbol(M, Decl(constDeclarations-access4.ts, 0, 0))
>x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
@ -124,6 +126,7 @@ M.x;
>x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
(M.x);
>(M.x) : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
>M.x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
>M : Symbol(M, Decl(constDeclarations-access4.ts, 0, 0))
>x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))

3
tests/baselines/reference/constDeclarations-access5.symbols
View File

@ -88,6 +88,8 @@ m.x--;
>x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
++((m.x));
>((m.x)) : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
>(m.x) : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
>m.x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
>m : Symbol(m, Decl(constDeclarations_access_2.ts, 0, 0))
>x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
@ -124,6 +126,7 @@ m.x;
>x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
(m.x);
>(m.x) : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
>m.x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
>m : Symbol(m, Decl(constDeclarations_access_2.ts, 0, 0))
>x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))

1
tests/baselines/reference/constInClassExpression.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/constInClassExpression.ts ===
let C = class {
>C : Symbol(C, Decl(constInClassExpression.ts, 0, 3))
>class { const a = 4;} : Symbol(C, Decl(constInClassExpression.ts, 0, 7))
const a = 4;
>a : Symbol(C.a, Decl(constInClassExpression.ts, 0, 15))

1
tests/baselines/reference/constructorFunctions.symbols
View File

@ -97,6 +97,7 @@ var c5_v2;
c5_v2 = class { };
>c5_v2 : Symbol(c5_v2, Decl(index.js, 36, 3))
>class { } : Symbol(c5_v2, Decl(index.js, 37, 7))
new c5_v2();
>c5_v2 : Symbol(c5_v2, Decl(index.js, 36, 3))

6
tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.symbols
View File

@ -32,6 +32,8 @@ function getFoo1(): Foo {
>Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 6, 1))
return class {
>class { static method1(arg) { arg.numProp = 10; } static method2(arg) { arg.strProp = "hello"; } } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 14, 10))
static method1(arg) {
>method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 14, 18))
>arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 15, 23))
@ -54,6 +56,8 @@ function getFoo2(): Foo {
>Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 6, 1))
return class {
>class { static method1 = (arg) => { arg.numProp = 10; } static method2 = (arg) => { arg.strProp = "hello"; } } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 25, 10))
static method1 = (arg) => {
>method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 25, 18))
>arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 26, 26))
@ -80,6 +84,8 @@ function getFoo3(): Foo {
>Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 6, 1))
return class {
>class { static method1 = function (arg) { arg.numProp = 10; } static method2 = function (arg) { arg.strProp = "hello"; } } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 36, 10))
static method1 = function (arg) {
>method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 36, 18))
>arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 37, 35))

6
tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.symbols
View File

@ -39,6 +39,8 @@ function getFoo1(): Foo {
>Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 6, 1))
return class {
>class { method1(arg) { arg.numProp = 10; } method2(arg) { arg.strProp = "hello"; } } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 18, 10))
method1(arg) {
>method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 18, 18))
>arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 19, 16))
@ -61,6 +63,8 @@ function getFoo2(): Foo {
>Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 6, 1))
return class {
>class { method1 = (arg) => { arg.numProp = 10; } method2 = (arg) => { arg.strProp = "hello"; } } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 29, 10))
method1 = (arg) => {
>method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 29, 18))
>arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 30, 19))
@ -83,6 +87,8 @@ function getFoo3(): Foo {
>Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 6, 1))
return class {
>class { method1 = function (arg) { arg.numProp = 10; } method2 = function (arg) { arg.strProp = "hello"; } } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 40, 10))
method1 = function (arg) {
>method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 40, 18))
>arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 41, 28))

2
tests/baselines/reference/controlFlowArrays.symbols
View File

@ -413,6 +413,8 @@ function f16() {
>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
((x))[3] = { a: 1 };
>((x)) : Symbol(x, Decl(controlFlowArrays.ts, 155, 7))
>(x) : Symbol(x, Decl(controlFlowArrays.ts, 155, 7))
>x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7))
>a : Symbol(a, Decl(controlFlowArrays.ts, 159, 16))

78
tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty1.symbols
View File

@ -5,11 +5,13 @@ const foo: any = {};
// properties
foo.x = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(x, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 3, 7))
constructor () {}
}
foo.y = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(y, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 6, 7))
constructor () {}
}
@ -17,381 +19,457 @@ foo.y = class {
// keywords
foo.break = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(break, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 11, 11))
constructor () {}
}
foo.case = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(case, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 14, 10))
constructor () {}
}
foo.catch = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(catch, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 17, 11))
constructor () {}
}
foo.class = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(class, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 20, 11))
constructor () {}
}
foo.const = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(const, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 23, 11))
constructor () {}
}
foo.continue = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(continue, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 26, 14))
constructor () {}
}
foo.debugger = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(debugger, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 29, 14))
constructor () {}
}
foo.default = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(default, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 32, 13))
constructor () {}
}
foo.delete = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(delete, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 35, 12))
constructor () {}
}
foo.do = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(do, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 38, 8))
constructor () {}
}
foo.else = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(else, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 41, 10))
constructor () {}
}
foo.enum = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(enum, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 44, 10))
constructor () {}
}
foo.export = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(export, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 47, 12))
constructor () {}
}
foo.extends = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(extends, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 50, 13))
constructor () {}
}
foo.false = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(false, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 53, 11))
constructor () {}
}
foo.finally = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(finally, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 56, 13))
constructor () {}
}
foo.for = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(for, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 59, 9))
constructor () {}
}
foo.function = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(function, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 62, 14))
constructor () {}
}
foo.if = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(if, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 65, 8))
constructor () {}
}
foo.import = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(import, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 68, 12))
constructor () {}
}
foo.in = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(in, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 71, 8))
constructor () {}
}
foo.instanceof = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(instanceof, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 74, 16))
constructor () {}
}
foo.new = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(new, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 77, 9))
constructor () {}
}
foo.null = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(null, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 80, 10))
constructor () {}
}
foo.return = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(return, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 83, 12))
constructor () {}
}
foo.super = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(super, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 86, 11))
constructor () {}
}
foo.switch = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(switch, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 89, 12))
constructor () {}
}
foo.this = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(this, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 92, 10))
constructor () {}
}
foo.throw = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(throw, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 95, 11))
constructor () {}
}
foo.true = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(true, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 98, 10))
constructor () {}
}
foo.try = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(try, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 101, 9))
constructor () {}
}
foo.typeof = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(typeof, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 104, 12))
constructor () {}
}
foo.var = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(var, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 107, 9))
constructor () {}
}
foo.void = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(void, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 110, 10))
constructor () {}
}
foo.while = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(while, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 113, 11))
constructor () {}
}
foo.with = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(with, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 116, 10))
constructor () {}
}
foo.implements = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(implements, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 119, 16))
constructor () {}
}
foo.interface = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(interface, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 122, 15))
constructor () {}
}
foo.let = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(let, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 125, 9))
constructor () {}
}
foo.package = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(package, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 128, 13))
constructor () {}
}
foo.private = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(private, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 131, 13))
constructor () {}
}
foo.protected = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(protected, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 134, 15))
constructor () {}
}
foo.public = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(public, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 137, 12))
constructor () {}
}
foo.static = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(static, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 140, 12))
constructor () {}
}
foo.yield = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(yield, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 143, 11))
constructor () {}
}
foo.abstract = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(abstract, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 146, 14))
constructor () {}
}
foo.as = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(as, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 149, 8))
constructor () {}
}
foo.asserts = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(asserts, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 152, 13))
constructor () {}
}
foo.any = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(any, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 155, 9))
constructor () {}
}
foo.async = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(async, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 158, 11))
constructor () {}
}
foo.await = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(await, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 161, 11))
constructor () {}
}
foo.boolean = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(boolean, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 164, 13))
constructor () {}
}
foo.constructor = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(constructor, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 167, 17))
constructor () {}
}
foo.declare = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(declare, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 170, 13))
constructor () {}
}
foo.get = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(get, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 173, 9))
constructor () {}
}
foo.infer = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(infer, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 176, 11))
constructor () {}
}
foo.is = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(is, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 179, 8))
constructor () {}
}
foo.keyof = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(keyof, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 182, 11))
constructor () {}
}
foo.module = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(module, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 185, 12))
constructor () {}
}
foo.namespace = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(namespace, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 188, 15))
constructor () {}
}
foo.never = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(never, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 191, 11))
constructor () {}
}
foo.readonly = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(readonly, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 194, 14))
constructor () {}
}
foo.require = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(require, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 197, 13))
constructor () {}
}
foo.number = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(number, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 200, 12))
constructor () {}
}
foo.object = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(object, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 203, 12))
constructor () {}
}
foo.set = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(set, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 206, 9))
constructor () {}
}
foo.string = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(string, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 209, 12))
constructor () {}
}
foo.symbol = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(symbol, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 212, 12))
constructor () {}
}
foo.type = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(type, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 215, 10))
constructor () {}
}
foo.undefined = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(undefined, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 218, 15))
constructor () {}
}
foo.unique = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(unique, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 221, 12))
constructor () {}
}
foo.unknown = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(unknown, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 224, 13))
constructor () {}
}
foo.from = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(from, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 227, 10))
constructor () {}
}
foo.global = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(global, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 230, 12))
constructor () {}
}
foo.bigint = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(bigint, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 233, 12))
constructor () {}
}
foo.of = class {
>foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
>class { constructor () {}} : Symbol(of, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 236, 8))
constructor () {}
}

78
tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty2.symbols
View File

@ -2,11 +2,13 @@
({
x: class {
>x : Symbol(x, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 0, 2))
>class { constructor() { } } : Symbol(x, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 1, 6))
constructor() { }
},
y: class {
>y : Symbol(y, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 3, 6))
>class { constructor() { } } : Symbol(y, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 4, 6))
constructor() { }
},
@ -14,381 +16,457 @@
// keywords
break: class {
>break : Symbol(break, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 6, 6))
>class { constructor() { } } : Symbol(break, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 9, 10))
constructor() { }
},
case: class {
>case : Symbol(case, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 11, 6))
>class { constructor() { } } : Symbol(case, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 12, 9))
constructor() { }
},
catch: class {
>catch : Symbol(catch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 14, 6))
>class { constructor() { } } : Symbol(catch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 15, 10))
constructor() { }
},
class: class {
>class : Symbol(class, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 17, 6))
>class { constructor() { } } : Symbol(class, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 18, 10))
constructor() { }
},
const: class {
>const : Symbol(const, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 20, 6))
>class { constructor() { } } : Symbol(const, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 21, 10))
constructor() { }
},
continue: class {
>continue : Symbol(continue, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 23, 6))
>class { constructor() { } } : Symbol(continue, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 24, 13))
constructor() { }
},
debugger: class {
>debugger : Symbol(debugger, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 26, 6))
>class { constructor() { } } : Symbol(debugger, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 27, 13))
constructor() { }
},
default: class {
>default : Symbol(default, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 29, 6))
>class { constructor() { } } : Symbol(default, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 30, 12))
constructor() { }
},
delete: class {
>delete : Symbol(delete, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 32, 6))
>class { constructor() { } } : Symbol(delete, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 33, 11))
constructor() { }
},
do: class {
>do : Symbol(do, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 35, 6))
>class { constructor() { } } : Symbol(do, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 36, 7))
constructor() { }
},
else: class {
>else : Symbol(else, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 38, 6))
>class { constructor() { } } : Symbol(else, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 39, 9))
constructor() { }
},
enum: class {
>enum : Symbol(enum, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 41, 6))
>class { constructor() { } } : Symbol(enum, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 42, 9))
constructor() { }
},
export: class {
>export : Symbol(export, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 44, 6))
>class { constructor() { } } : Symbol(export, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 45, 11))
constructor() { }
},
extends: class {
>extends : Symbol(extends, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 47, 6))
>class { constructor() { } } : Symbol(extends, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 48, 12))
constructor() { }
},
false: class {
>false : Symbol(false, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 50, 6))
>class { constructor() { } } : Symbol(false, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 51, 10))
constructor() { }
},
finally: class {
>finally : Symbol(finally, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 53, 6))
>class { constructor() { } } : Symbol(finally, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 54, 12))
constructor() { }
},
for: class {
>for : Symbol(for, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 56, 6))
>class { constructor() { } } : Symbol(for, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 57, 8))
constructor() { }
},
function: class {
>function : Symbol(function, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 59, 6))
>class { constructor() { } } : Symbol(function, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 60, 13))
constructor() { }
},
if: class {
>if : Symbol(if, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 62, 6))
>class { constructor() { } } : Symbol(if, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 63, 7))
constructor() { }
},
import: class {
>import : Symbol(import, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 65, 6))
>class { constructor() { } } : Symbol(import, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 66, 11))
constructor() { }
},
in: class {
>in : Symbol(in, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 68, 6))
>class { constructor() { } } : Symbol(in, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 69, 7))
constructor() { }
},
instanceof: class {
>instanceof : Symbol(instanceof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 71, 6))
>class { constructor() { } } : Symbol(instanceof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 72, 15))
constructor() { }
},
new: class {
>new : Symbol(new, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 74, 6))
>class { constructor() { } } : Symbol(new, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 75, 8))
constructor() { }
},
null: class {
>null : Symbol(null, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 77, 6))
>class { constructor() { } } : Symbol(null, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 78, 9))
constructor() { }
},
return: class {
>return : Symbol(return, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 80, 6))
>class { constructor() { } } : Symbol(return, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 81, 11))
constructor() { }
},
super: class {
>super : Symbol(super, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 83, 6))
>class { constructor() { } } : Symbol(super, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 84, 10))
constructor() { }
},
switch: class {
>switch : Symbol(switch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 86, 6))
>class { constructor() { } } : Symbol(switch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 87, 11))
constructor() { }
},
this: class {
>this : Symbol(this, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 89, 6))
>class { constructor() { } } : Symbol(this, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 90, 9))
constructor() { }
},
throw: class {
>throw : Symbol(throw, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 92, 6))
>class { constructor() { } } : Symbol(throw, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 93, 10))
constructor() { }
},
true: class {
>true : Symbol(true, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 95, 6))
>class { constructor() { } } : Symbol(true, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 96, 9))
constructor() { }
},
try: class {
>try : Symbol(try, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 98, 6))
>class { constructor() { } } : Symbol(try, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 99, 8))
constructor() { }
},
typeof: class {
>typeof : Symbol(typeof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 101, 6))
>class { constructor() { } } : Symbol(typeof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 102, 11))
constructor() { }
},
var: class {
>var : Symbol(var, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 104, 6))
>class { constructor() { } } : Symbol(var, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 105, 8))
constructor() { }
},
void: class {
>void : Symbol(void, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 107, 6))
>class { constructor() { } } : Symbol(void, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 108, 9))
constructor() { }
},
while: class {
>while : Symbol(while, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 110, 6))
>class { constructor() { } } : Symbol(while, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 111, 10))
constructor() { }
},
with: class {
>with : Symbol(with, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 113, 6))
>class { constructor() { } } : Symbol(with, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 114, 9))
constructor() { }
},
implements: class {
>implements : Symbol(implements, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 116, 6))
>class { constructor() { } } : Symbol(implements, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 117, 15))
constructor() { }
},
interface: class {
>interface : Symbol(interface, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 119, 6))
>class { constructor() { } } : Symbol(interface, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 120, 14))
constructor() { }
},
let: class {
>let : Symbol(let, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 122, 6))
>class { constructor() { } } : Symbol(let, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 123, 8))
constructor() { }
},
package: class {
>package : Symbol(package, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 125, 6))
>class { constructor() { } } : Symbol(package, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 126, 12))
constructor() { }
},
private: class {
>private : Symbol(private, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 128, 6))
>class { constructor() { } } : Symbol(private, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 129, 12))
constructor() { }
},
protected: class {
>protected : Symbol(protected, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 131, 6))
>class { constructor() { } } : Symbol(protected, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 132, 14))
constructor() { }
},
public: class {
>public : Symbol(public, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 134, 6))
>class { constructor() { } } : Symbol(public, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 135, 11))
constructor() { }
},
static: class {
>static : Symbol(static, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 137, 6))
>class { constructor() { } } : Symbol(static, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 138, 11))
constructor() { }
},
yield: class {
>yield : Symbol(yield, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 140, 6))
>class { constructor() { } } : Symbol(yield, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 141, 10))
constructor() { }
},
abstract: class {
>abstract : Symbol(abstract, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 143, 6))
>class { constructor() { } } : Symbol(abstract, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 144, 13))
constructor() { }
},
as: class {
>as : Symbol(as, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 146, 6))
>class { constructor() { } } : Symbol(as, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 147, 7))
constructor() { }
},
asserts: class {
>asserts : Symbol(asserts, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 149, 6))
>class { constructor() { } } : Symbol(asserts, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 150, 12))
constructor() { }
},
any: class {
>any : Symbol(any, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 152, 6))
>class { constructor() { } } : Symbol(any, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 153, 8))
constructor() { }
},
async: class {
>async : Symbol(async, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 155, 6))
>class { constructor() { } } : Symbol(async, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 156, 10))
constructor() { }
},
await: class {
>await : Symbol(await, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 158, 6))
>class { constructor() { } } : Symbol(await, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 159, 10))
constructor() { }
},
boolean: class {
>boolean : Symbol(boolean, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 161, 6))
>class { constructor() { } } : Symbol(boolean, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 162, 12))
constructor() { }
},
constructor: class {
>constructor : Symbol(constructor, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 164, 6))
>class { constructor() { } } : Symbol(constructor, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 165, 16))
constructor() { }
},
declare: class {
>declare : Symbol(declare, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 167, 6))
>class { constructor() { } } : Symbol(declare, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 168, 12))
constructor() { }
},
get: class {
>get : Symbol(get, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 170, 6))
>class { constructor() { } } : Symbol(get, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 171, 8))
constructor() { }
},
infer: class {
>infer : Symbol(infer, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 173, 6))
>class { constructor() { } } : Symbol(infer, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 174, 10))
constructor() { }
},
is: class {
>is : Symbol(is, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 176, 6))
>class { constructor() { } } : Symbol(is, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 177, 7))
constructor() { }
},
keyof: class {
>keyof : Symbol(keyof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 179, 6))
>class { constructor() { } } : Symbol(keyof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 180, 10))
constructor() { }
},
module: class {
>module : Symbol(module, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 182, 6))
>class { constructor() { } } : Symbol(module, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 183, 11))
constructor() { }
},
namespace: class {
>namespace : Symbol(namespace, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 185, 6))
>class { constructor() { } } : Symbol(namespace, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 186, 14))
constructor() { }
},
never: class {
>never : Symbol(never, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 188, 6))
>class { constructor() { } } : Symbol(never, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 189, 10))
constructor() { }
},
readonly: class {
>readonly : Symbol(readonly, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 191, 6))
>class { constructor() { } } : Symbol(readonly, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 192, 13))
constructor() { }
},
require: class {
>require : Symbol(require, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 194, 6))
>class { constructor() { } } : Symbol(require, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 195, 12))
constructor() { }
},
number: class {
>number : Symbol(number, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 197, 6))
>class { constructor() { } } : Symbol(number, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 198, 11))
constructor() { }
},
object: class {
>object : Symbol(object, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 200, 6))
>class { constructor() { } } : Symbol(object, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 201, 11))
constructor() { }
},
set: class {
>set : Symbol(set, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 203, 6))
>class { constructor() { } } : Symbol(set, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 204, 8))
constructor() { }
},
string: class {
>string : Symbol(string, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 206, 6))
>class { constructor() { } } : Symbol(string, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 207, 11))
constructor() { }
},
symbol: class {
>symbol : Symbol(symbol, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 209, 6))
>class { constructor() { } } : Symbol(symbol, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 210, 11))
constructor() { }
},
type: class {
>type : Symbol(type, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 212, 6))
>class { constructor() { } } : Symbol(type, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 213, 9))
constructor() { }
},
undefined: class {
>undefined : Symbol(undefined, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 215, 6))
>class { constructor() { } } : Symbol(undefined, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 216, 14))
constructor() { }
},
unique: class {
>unique : Symbol(unique, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 218, 6))
>class { constructor() { } } : Symbol(unique, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 219, 11))
constructor() { }
},
unknown: class {
>unknown : Symbol(unknown, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 221, 6))
>class { constructor() { } } : Symbol(unknown, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 222, 12))
constructor() { }
},
from: class {
>from : Symbol(from, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 224, 6))
>class { constructor() { } } : Symbol(from, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 225, 9))
constructor() { }
},
global: class {
>global : Symbol(global, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 227, 6))
>class { constructor() { } } : Symbol(global, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 228, 11))
constructor() { }
},
bigint: class {
>bigint : Symbol(bigint, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 230, 6))
>class { constructor() { } } : Symbol(bigint, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 231, 11))
constructor() { }
},
of: class {
>of : Symbol(of, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 233, 6))
>class { constructor() { } } : Symbol(of, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 234, 7))
constructor() { }
}

1
tests/baselines/reference/declarationEmitExpressionInExtends4.symbols
View File

@ -3,6 +3,7 @@ function getSomething() {
>getSomething : Symbol(getSomething, Decl(declarationEmitExpressionInExtends4.ts, 0, 0))
return class D { }
>class D { } : Symbol(D, Decl(declarationEmitExpressionInExtends4.ts, 1, 10))
>D : Symbol(D, Decl(declarationEmitExpressionInExtends4.ts, 1, 10))
}

2
tests/baselines/reference/declarationEmitMixinPrivateProtected.symbols
View File

@ -8,6 +8,7 @@ declare function mix<TMix>(mixin: TMix): TMix;
const DisposableMixin = class {
>DisposableMixin : Symbol(DisposableMixin, Decl(first.ts, 2, 5))
>class { protected _onDispose() { this._assertIsStripped() } private _assertIsStripped() { }} : Symbol(DisposableMixin, Decl(first.ts, 2, 23))
protected _onDispose() {
>_onDispose : Symbol(DisposableMixin._onDispose, Decl(first.ts, 2, 31))
@ -47,6 +48,7 @@ declare function mix<TMix>(mixin: TMix): TMix;
const DisposableMixin = class {
>DisposableMixin : Symbol(DisposableMixin, Decl(another.ts, 2, 5))
>class { protected _onDispose() { this._assertIsStripped() } private _assertIsStripped() { }} : Symbol(DisposableMixin, Decl(another.ts, 2, 23))
protected _onDispose() {
>_onDispose : Symbol(DisposableMixin._onDispose, Decl(another.ts, 2, 31))

1
tests/baselines/reference/declarationEmitPrivateNameCausesError.symbols
View File

@ -12,6 +12,7 @@ export function ignoreExtraVariables<CtorT extends {new(...args:any[]):{}}> (cto
>CtorT : Symbol(CtorT, Decl(file.ts, 3, 37))
return class extends ctor {
>class extends ctor { [IGNORE_EXTRA_VARIABLES] = true; //An unexported constant is used } : Symbol((Anonymous class), Decl(file.ts, 4, 10))
>ctor : Symbol(ctor, Decl(file.ts, 3, 77))
[IGNORE_EXTRA_VARIABLES] = true; //An unexported constant is used

2
tests/baselines/reference/declarationNoDanglingGenerics.symbols
View File

@ -31,6 +31,8 @@ function ClassFactory<TKind extends string>(kind: TKind) {
>kind : Symbol(kind, Decl(declarationNoDanglingGenerics.ts, 9, 44))
return class {
>class { static readonly THE_KIND: TKind = kind; readonly kind: TKind = kind; } : Symbol((Anonymous class), Decl(declarationNoDanglingGenerics.ts, 12, 8))
static readonly THE_KIND: TKind = kind;
>THE_KIND : Symbol((Anonymous class).THE_KIND, Decl(declarationNoDanglingGenerics.ts, 12, 16))
>TKind : Symbol(TKind, Decl(declarationNoDanglingGenerics.ts, 9, 22))

1
tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
View File

@ -24,6 +24,7 @@ export const mixin = (Base: Constructor) => {
>Constructor : Symbol(Constructor, Decl(index.ts, 1, 31))
return class extends Base {
>class extends Base { get(domNode: DOMNode) {} } : Symbol((Anonymous class), Decl(index.ts, 6, 8))
>Base : Symbol(Base, Decl(index.ts, 5, 22))
get(domNode: DOMNode) {}

5
tests/baselines/reference/decoratorsOnComputedProperties.symbols
View File

@ -98,6 +98,7 @@ class A {
}
void class B {
>class B { @x ["property"]: any; @x [Symbol.toStringTag]: any; @x ["property2"]: any = 2; @x [Symbol.iterator]: any = null; ["property3"]: any; [Symbol.isConcatSpreadable]: any; ["property4"]: any = 2; [Symbol.match]: any = null; [foo()]: any; @x [foo()]: any; @x [foo()]: any = null; [fieldNameA]: any; @x [fieldNameB]: any; @x [fieldNameC]: any = null;} : Symbol(B, Decl(decoratorsOnComputedProperties.ts, 25, 4))
>B : Symbol(B, Decl(decoratorsOnComputedProperties.ts, 25, 4))
@x ["property"]: any;
@ -254,6 +255,7 @@ class C {
}
void class D {
>class D { @x ["property"]: any; @x [Symbol.toStringTag]: any; @x ["property2"]: any = 2; @x [Symbol.iterator]: any = null; ["property3"]: any; [Symbol.isConcatSpreadable]: any; ["property4"]: any = 2; [Symbol.match]: any = null; [foo()]: any; @x [foo()]: any; @x [foo()]: any = null; [fieldNameA]: any; @x [fieldNameB]: any; @x [fieldNameC]: any = null; ["some" + "method"]() {}} : Symbol(D, Decl(decoratorsOnComputedProperties.ts, 60, 4))
>D : Symbol(D, Decl(decoratorsOnComputedProperties.ts, 60, 4))
@x ["property"]: any;
@ -413,6 +415,7 @@ class E {
}
void class F {
>class F { @x ["property"]: any; @x [Symbol.toStringTag]: any; @x ["property2"]: any = 2; @x [Symbol.iterator]: any = null; ["property3"]: any; [Symbol.isConcatSpreadable]: any; ["property4"]: any = 2; [Symbol.match]: any = null; [foo()]: any; @x [foo()]: any; @x [foo()]: any = null; ["some" + "method"]() {} [fieldNameA]: any; @x [fieldNameB]: any; @x [fieldNameC]: any = null;} : Symbol(F, Decl(decoratorsOnComputedProperties.ts, 96, 4))
>F : Symbol(F, Decl(decoratorsOnComputedProperties.ts, 96, 4))
@x ["property"]: any;
@ -575,6 +578,7 @@ class G {
}
void class H {
>class H { @x ["property"]: any; @x [Symbol.toStringTag]: any; @x ["property2"]: any = 2; @x [Symbol.iterator]: any = null; ["property3"]: any; [Symbol.isConcatSpreadable]: any; ["property4"]: any = 2; [Symbol.match]: any = null; [foo()]: any; @x [foo()]: any; @x [foo()]: any = null; ["some" + "method"]() {} [fieldNameA]: any; @x [fieldNameB]: any; ["some" + "method2"]() {} @x [fieldNameC]: any = null;} : Symbol(H, Decl(decoratorsOnComputedProperties.ts, 133, 4))
>H : Symbol(H, Decl(decoratorsOnComputedProperties.ts, 133, 4))
@x ["property"]: any;
@ -741,6 +745,7 @@ class I {
}
void class J {
>class J { @x ["property"]: any; @x [Symbol.toStringTag]: any; @x ["property2"]: any = 2; @x [Symbol.iterator]: any = null; ["property3"]: any; [Symbol.isConcatSpreadable]: any; ["property4"]: any = 2; [Symbol.match]: any = null; [foo()]: any; @x [foo()]: any; @x [foo()]: any = null; @x ["some" + "method"]() {} [fieldNameA]: any; @x [fieldNameB]: any; ["some" + "method2"]() {} @x [fieldNameC]: any = null;} : Symbol(J, Decl(decoratorsOnComputedProperties.ts, 171, 4))
>J : Symbol(J, Decl(decoratorsOnComputedProperties.ts, 171, 4))
@x ["property"]: any;

6
tests/baselines/reference/decrementAndIncrementOperators.symbols
View File

@ -47,15 +47,21 @@ x--;
>x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
(x)++;
>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
>x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
--(x);
>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
>x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
((x))++;
>((x)) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
>x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
((x))--;
>((x)) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
>x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
x[x++]++;

1
tests/baselines/reference/defaultValueInFunctionTypes.symbols
View File

@ -6,5 +6,6 @@ var x: (a: number = 1) => number;
var y = <(a : string = "") => any>(undefined)
>y : Symbol(y, Decl(defaultValueInFunctionTypes.ts, 1, 3))
>a : Symbol(a, Decl(defaultValueInFunctionTypes.ts, 1, 10))
>(undefined) : Symbol(undefined)
>undefined : Symbol(undefined)

6
tests/baselines/reference/deleteChain.symbols
View File

@ -9,6 +9,7 @@ delete o1?.b;
>b : Symbol(b, Decl(deleteChain.ts, 0, 31))
delete (o1?.b);
>(o1?.b) : Symbol(b, Decl(deleteChain.ts, 0, 31))
>o1?.b : Symbol(b, Decl(deleteChain.ts, 0, 31))
>o1 : Symbol(o1, Decl(deleteChain.ts, 0, 13))
>b : Symbol(b, Decl(deleteChain.ts, 0, 31))
@ -26,6 +27,7 @@ delete o2?.b.c;
>c : Symbol(c, Decl(deleteChain.ts, 4, 36))
delete (o2?.b.c);
>(o2?.b.c) : Symbol(c, Decl(deleteChain.ts, 4, 36))
>o2?.b.c : Symbol(c, Decl(deleteChain.ts, 4, 36))
>o2?.b : Symbol(b, Decl(deleteChain.ts, 4, 31))
>o2 : Symbol(o2, Decl(deleteChain.ts, 4, 13))
@ -45,6 +47,7 @@ delete o3.b?.c;
>c : Symbol(c, Decl(deleteChain.ts, 8, 36))
delete (o3.b?.c);
>(o3.b?.c) : Symbol(c, Decl(deleteChain.ts, 8, 36))
>o3.b?.c : Symbol(c, Decl(deleteChain.ts, 8, 36))
>o3.b : Symbol(b, Decl(deleteChain.ts, 8, 19))
>o3 : Symbol(o3, Decl(deleteChain.ts, 8, 13))
@ -71,6 +74,7 @@ delete o4.b?.c.d?.e;
delete (o4.b?.c.d)?.e;
>(o4.b?.c.d)?.e : Symbol(e, Decl(deleteChain.ts, 12, 36))
>(o4.b?.c.d) : Symbol(d, Decl(deleteChain.ts, 12, 30))
>o4.b?.c.d : Symbol(d, Decl(deleteChain.ts, 12, 30))
>o4.b?.c : Symbol(c, Decl(deleteChain.ts, 12, 25))
>o4.b : Symbol(b, Decl(deleteChain.ts, 12, 19))
@ -81,6 +85,7 @@ delete (o4.b?.c.d)?.e;
>e : Symbol(e, Decl(deleteChain.ts, 12, 36))
delete (o4.b?.c.d?.e);
>(o4.b?.c.d?.e) : Symbol(e, Decl(deleteChain.ts, 12, 36))
>o4.b?.c.d?.e : Symbol(e, Decl(deleteChain.ts, 12, 36))
>o4.b?.c.d : Symbol(d, Decl(deleteChain.ts, 12, 30))
>o4.b?.c : Symbol(c, Decl(deleteChain.ts, 12, 25))
@ -110,6 +115,7 @@ delete o5.b?.().c.d?.e;
>e : Symbol(e, Decl(deleteChain.ts, 17, 38))
delete (o5.b?.().c.d?.e);
>(o5.b?.().c.d?.e) : Symbol(e, Decl(deleteChain.ts, 17, 38))
>o5.b?.().c.d?.e : Symbol(e, Decl(deleteChain.ts, 17, 38))
>o5.b?.().c.d : Symbol(d, Decl(deleteChain.ts, 17, 32))
>o5.b?.().c : Symbol(c, Decl(deleteChain.ts, 17, 27))

15
tests/baselines/reference/derivedClassSuperProperties.symbols
View File

@ -413,6 +413,7 @@ class DerivedWithClassDeclarationExtendingMember extends Base {
memberClass = class { };
>memberClass : Symbol(DerivedWithClassDeclarationExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 192, 63))
>class { } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 193, 17))
constructor() {
class InnerClass extends this.memberClass {
@ -462,6 +463,7 @@ class DerivedWithClassExpression extends Base {
>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>class { private method() { return this; } private property = 7; constructor() { this.property; this.method(); } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 213, 20))
private method() {
>method : Symbol((Anonymous class).method, Decl(derivedClassSuperProperties.ts, 213, 27))
@ -495,12 +497,14 @@ class DerivedWithClassExpressionExtendingMember extends Base {
memberClass = class { };
>memberClass : Symbol(DerivedWithClassExpressionExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 227, 62))
>class { } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 228, 17))
constructor() {
console.log(class extends this.memberClass { });
>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>class extends this.memberClass { } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 230, 20))
>this.memberClass : Symbol(DerivedWithClassExpressionExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 227, 62))
>this : Symbol(DerivedWithClassExpressionExtendingMember, Decl(derivedClassSuperProperties.ts, 225, 1))
>memberClass : Symbol(DerivedWithClassExpressionExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 227, 62))
@ -522,6 +526,7 @@ class DerivedWithDerivedClassExpression extends Base {
>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>class extends Base { constructor() { super(); } public foo() { return this; } public bar = () => this; } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 238, 20))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
constructor() {
@ -556,6 +561,7 @@ class DerivedWithNewDerivedClassExpression extends Base {
>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
>class extends Base { constructor() { super(); } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 254, 23))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
constructor() {
@ -743,6 +749,7 @@ const DerivedWithLoops = [
>DerivedWithLoops : Symbol(DerivedWithLoops, Decl(derivedClassSuperProperties.ts, 344, 5))
class extends Base {
>class extends Base { prop = true; constructor() { for(super();;) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 344, 26))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -754,6 +761,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { for(a; super();) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 350, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -766,6 +774,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { for(a; b; super()) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 356, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -779,6 +788,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { for(; ; super()) { break; } } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 362, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -790,6 +800,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { for (const x of super()) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 368, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -802,6 +813,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { while (super()) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 374, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -813,6 +825,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { do {} while (super()); } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 380, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -824,6 +837,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { if (super()) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 386, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;
@ -835,6 +849,7 @@ const DerivedWithLoops = [
}
},
class extends Base {
>class extends Base { prop = true; constructor() { switch (super()) {} } } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 392, 6))
>Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
prop = true;

2
tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.symbols
View File

@ -9,6 +9,7 @@ const Mixin1 = <C extends Constructor>(Base: C) => class extends Base { private
>Constructor : Symbol(Constructor, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 0, 0))
>Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 39))
>C : Symbol(C, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 16))
>class extends Base { private _fooPrivate: {}; } : Symbol((Anonymous class), Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 50))
>Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 39))
>_fooPrivate : Symbol((Anonymous class)._fooPrivate, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 71))
@ -26,6 +27,7 @@ const Mixin2 = <C extends FooConstructor>(Base: C) => class extends Base {};
>FooConstructor : Symbol(FooConstructor, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 98))
>Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 42))
>C : Symbol(C, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 16))
>class extends Base {} : Symbol((Anonymous class), Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 53))
>Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 42))
class C extends Mixin2(Mixin1(Object)) {}

3
tests/baselines/reference/emitClassExpressionInDeclarationFile.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/emitClassExpressionInDeclarationFile.ts ===
export var simpleExample = class {
>simpleExample : Symbol(simpleExample, Decl(emitClassExpressionInDeclarationFile.ts, 0, 10))
>class { static getTags() { } tags() { }} : Symbol(simpleExample, Decl(emitClassExpressionInDeclarationFile.ts, 0, 26))
static getTags() { }
>getTags : Symbol(simpleExample.getTags, Decl(emitClassExpressionInDeclarationFile.ts, 0, 34))
@ -10,6 +11,7 @@ export var simpleExample = class {
}
export var circularReference = class C {
>circularReference : Symbol(circularReference, Decl(emitClassExpressionInDeclarationFile.ts, 4, 10))
>class C { static getTags(c: C): C { return c } tags(c: C): C { return c }} : Symbol(C, Decl(emitClassExpressionInDeclarationFile.ts, 4, 30))
>C : Symbol(C, Decl(emitClassExpressionInDeclarationFile.ts, 4, 30))
static getTags(c: C): C { return c }
@ -53,6 +55,7 @@ export function WithTags<T extends Constructor<FooItem>>(Base: T) {
>T : Symbol(T, Decl(emitClassExpressionInDeclarationFile.ts, 16, 25))
return class extends Base {
>class extends Base { static getTags(): void { } tags(): void { } } : Symbol((Anonymous class), Decl(emitClassExpressionInDeclarationFile.ts, 17, 10))
>Base : Symbol(Base, Decl(emitClassExpressionInDeclarationFile.ts, 16, 57))
static getTags(): void { }

2
tests/baselines/reference/emitClassExpressionInDeclarationFile2.symbols
View File

@ -1,6 +1,7 @@
=== tests/cases/compiler/emitClassExpressionInDeclarationFile2.ts ===
export var noPrivates = class {
>noPrivates : Symbol(noPrivates, Decl(emitClassExpressionInDeclarationFile2.ts, 0, 10))
>class { static getTags() { } tags() { } private static ps = -1 private p = 12} : Symbol(noPrivates, Decl(emitClassExpressionInDeclarationFile2.ts, 0, 23))
static getTags() { }
>getTags : Symbol(noPrivates.getTags, Decl(emitClassExpressionInDeclarationFile2.ts, 0, 31))
@ -44,6 +45,7 @@ export function WithTags<T extends Constructor<FooItem>>(Base: T) {
>T : Symbol(T, Decl(emitClassExpressionInDeclarationFile2.ts, 15, 25))
return class extends Base {
>class extends Base { static getTags(): void { } tags(): void { } } : Symbol((Anonymous class), Decl(emitClassExpressionInDeclarationFile2.ts, 16, 10))
>Base : Symbol(Base, Decl(emitClassExpressionInDeclarationFile2.ts, 15, 57))
static getTags(): void { }

1
tests/baselines/reference/ensureNoCrashExportAssignmentDefineProperrtyPotentialMerge.symbols
View File

@ -25,6 +25,7 @@ A.bar = class Q {}
>A.bar : Symbol(A.bar, Decl(namespacey.js, 0, 12))
>A : Symbol(A, Decl(namespacey.js, 0, 5), Decl(namespacey.js, 0, 12))
>bar : Symbol(A.bar, Decl(namespacey.js, 0, 12))
>class Q {} : Symbol(Q, Decl(namespacey.js, 1, 7))
>Q : Symbol(Q, Decl(namespacey.js, 1, 7))
module.exports = A;

1
tests/baselines/reference/errorsWithInvokablesInUnions01.symbols
View File

@ -42,6 +42,7 @@ export let ctor: IDirectiveLinkFn<number> | ConstructableA | IDirectivePrePost<n
>IDirectiveLinkFn : Symbol(IDirectiveLinkFn, Decl(errorsWithInvokablesInUnions01.ts, 2, 1))
>ConstructableA : Symbol(ConstructableA, Decl(errorsWithInvokablesInUnions01.ts, 0, 0))
>IDirectivePrePost : Symbol(IDirectivePrePost, Decl(errorsWithInvokablesInUnions01.ts, 6, 1))
>class { someUnaccountedProp: any;} : Symbol(ctor, Decl(errorsWithInvokablesInUnions01.ts, 15, 88))
someUnaccountedProp: any;
>someUnaccountedProp : Symbol(ctor.someUnaccountedProp, Decl(errorsWithInvokablesInUnions01.ts, 15, 96))

1
tests/baselines/reference/exportAssignNonIdentifier.symbols
View File

@ -10,6 +10,7 @@ export = "sausages"; // Ok
No type information for this code.
No type information for this code.=== tests/cases/conformance/externalModules/foo3.ts ===
export = class Foo3 {}; // Error, not an expression
>class Foo3 {} : Symbol(Foo3, Decl(foo3.ts, 0, 8))
>Foo3 : Symbol(Foo3, Decl(foo3.ts, 0, 8))
=== tests/cases/conformance/externalModules/foo4.ts ===

1
tests/baselines/reference/exportClassExtendingIntersection.symbols
View File

@ -40,6 +40,7 @@ export function MyMixin<T extends Constructor<MyBaseClass<any>>>(base: T): T & C
>MyMixin : Symbol(MyMixin, Decl(MixinClass.ts, 4, 1), Decl(MixinClass.ts, 0, 55))
return class extends base {
>class extends base { mixinProperty: string; } : Symbol((Anonymous class), Decl(MixinClass.ts, 7, 10))
>base : Symbol(base, Decl(MixinClass.ts, 6, 65))
mixinProperty: string;

1
tests/baselines/reference/exportDefaultParenthesizeES6.symbols
View File

@ -1,4 +1,5 @@
=== tests/cases/compiler/classexpr.ts ===
export default (class Foo {} as any);
>class Foo {} : Symbol(Foo, Decl(classexpr.ts, 0, 16))
>Foo : Symbol(Foo, Decl(classexpr.ts, 0, 16))

1
tests/baselines/reference/exportNestedNamespaces.symbols
View File

@ -20,6 +20,7 @@ exports.Classic = class {
>exports.Classic : Symbol(Classic, Decl(mod.js, 3, 1))
>exports : Symbol(Classic, Decl(mod.js, 3, 1))
>Classic : Symbol(Classic, Decl(mod.js, 3, 1))
>class { constructor() { this.p = 1 }} : Symbol(Classic, Decl(mod.js, 4, 17))
constructor() {
this.p = 1

1
tests/baselines/reference/exportPropertyAssignmentNameResolution.symbols
View File

@ -5,6 +5,7 @@ module.exports.D = class { }
>module : Symbol(module, Decl(bug24492.js, 0, 0))
>exports : Symbol(module.exports, Decl(bug24492.js, 0, 0))
>D : Symbol(D, Decl(bug24492.js, 0, 0))
>class { } : Symbol(D, Decl(bug24492.js, 0, 18))
new D()

Some files were not shown because too many files have changed in this diff Show More