From b8329a05c3ea5611e34581f0704b80eef3e461c6 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 22 Jan 2017 10:45:23 -0800 Subject: [PATCH 1/6] basic support for declaring properties on funcitons --- src/compiler/binder.ts | 30 +++++++++++++++++++ src/compiler/checker.ts | 29 +++++++++++------- src/compiler/types.ts | 4 ++- src/compiler/utilities.ts | 9 ++++++ .../fourslash/renameJsPropertyAssignment.ts | 11 +++++++ 5 files changed, 71 insertions(+), 12 deletions(-) create mode 100644 tests/cases/fourslash/renameJsPropertyAssignment.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 712c96a49f..da1ba46653 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -265,6 +265,7 @@ namespace ts { return "export="; case SpecialPropertyAssignmentKind.ExportsProperty: case SpecialPropertyAssignmentKind.ThisProperty: + case SpecialPropertyAssignmentKind.Property: // exports.x = ... or this.y = ... return ((node as BinaryExpression).left as PropertyAccessExpression).name.text; case SpecialPropertyAssignmentKind.PrototypeProperty: @@ -1921,6 +1922,9 @@ namespace ts { case SpecialPropertyAssignmentKind.ThisProperty: bindThisPropertyAssignment(node); break; + case SpecialPropertyAssignmentKind.Property: + bindPropertyAssignment(node); + break; case SpecialPropertyAssignmentKind.None: // Nothing to do break; @@ -2225,6 +2229,32 @@ namespace ts { declareSymbol(funcSymbol.members, funcSymbol, leftSideOfAssignment, SymbolFlags.Property, SymbolFlags.PropertyExcludes); } + function bindPropertyAssignment(node: BinaryExpression) { + // We saw a node of the form 'x.y = z'. Declare a 'member' y on x if x was a function. + + // Look up the function in the local scope, since prototype assignments should + // follow the function declaration + const leftSideOfAssignment = node.left as PropertyAccessExpression; + const target = leftSideOfAssignment.expression as Identifier; + + // Fix up parent pointers since we're going to use these nodes before we bind into them + leftSideOfAssignment.parent = node; + target.parent = leftSideOfAssignment; + + const funcSymbol = container.locals[target.text]; + if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) { + return; + } + + // Set up the members collection if it doesn't exist already + if (!funcSymbol.exports) { + funcSymbol.exports = createMap(); + } + + // Declare the method/property + declareSymbol(funcSymbol.exports, funcSymbol, leftSideOfAssignment, SymbolFlags.Property, SymbolFlags.PropertyExcludes); + } + function bindCallExpression(node: CallExpression) { // We're only inspecting call expressions to detect CommonJS modules, so we can skip // this check if we've already seen the module indicator diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index bd8ff7568f..78f67ae438 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4580,7 +4580,7 @@ namespace ts { // Combinations of function, class, enum and module let members = emptySymbols; let constructSignatures: Signature[] = emptyArray; - if (symbol.flags & SymbolFlags.HasExports) { + if (symbol.exports) { members = getExportsOfSymbol(symbol); } if (symbol.flags & SymbolFlags.Class) { @@ -19871,22 +19871,29 @@ namespace ts { return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; } + function getSpecialPropertyAssignmentSymbolFromEntityName(entityName: EntityName | PropertyAccessExpression) { + const specialPropertyAssignmentKind = getSpecialPropertyAssignmentKind(entityName.parent.parent); + switch (specialPropertyAssignmentKind) { + case SpecialPropertyAssignmentKind.ExportsProperty: + case SpecialPropertyAssignmentKind.PrototypeProperty: + return getSymbolOfNode(entityName.parent); + case SpecialPropertyAssignmentKind.ThisProperty: + case SpecialPropertyAssignmentKind.ModuleExports: + case SpecialPropertyAssignmentKind.Property: + return getSymbolOfNode(entityName.parent.parent); + } + } + function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol | undefined { if (isDeclarationName(entityName)) { return getSymbolOfNode(entityName.parent); } if (isInJavaScriptFile(entityName) && entityName.parent.kind === SyntaxKind.PropertyAccessExpression) { - const specialPropertyAssignmentKind = getSpecialPropertyAssignmentKind(entityName.parent.parent); - switch (specialPropertyAssignmentKind) { - case SpecialPropertyAssignmentKind.ExportsProperty: - case SpecialPropertyAssignmentKind.PrototypeProperty: - return getSymbolOfNode(entityName.parent); - case SpecialPropertyAssignmentKind.ThisProperty: - case SpecialPropertyAssignmentKind.ModuleExports: - return getSymbolOfNode(entityName.parent.parent); - default: - // Fall through if it is not a special property assignment + // Check if this is a special property assignment + const specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(entityName); + if (specialPropertyAssignmentSymbol) { + return specialPropertyAssignmentSymbol; } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c16c199d3e..8fa47183a7 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -3133,7 +3133,9 @@ /// className.prototype.name = expr PrototypeProperty, /// this.name = expr - ThisProperty + ThisProperty, + // F.name = expr + Property } export interface FileExtensionInfo { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index b7cc0f0de6..5cd0746b03 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1374,6 +1374,10 @@ namespace ts { return false; } + export function isValidSpecialPropertyAssignmentParent(parentSymbol: Symbol) { + return parentSymbol && (parentSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(parentSymbol)); + } + /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property /// assignments we treat as special in the binder export function getSpecialPropertyAssignmentKind(expression: Node): SpecialPropertyAssignmentKind { @@ -1398,6 +1402,10 @@ namespace ts { // module.exports = expr return SpecialPropertyAssignmentKind.ModuleExports; } + else { + // F.x = expr + return SpecialPropertyAssignmentKind.Property; + } } else if (lhs.expression.kind === SyntaxKind.ThisKeyword) { return SpecialPropertyAssignmentKind.ThisProperty; @@ -1417,6 +1425,7 @@ namespace ts { } } + return SpecialPropertyAssignmentKind.None; } diff --git a/tests/cases/fourslash/renameJsPropertyAssignment.ts b/tests/cases/fourslash/renameJsPropertyAssignment.ts new file mode 100644 index 0000000000..fd1ba47569 --- /dev/null +++ b/tests/cases/fourslash/renameJsPropertyAssignment.ts @@ -0,0 +1,11 @@ +/// + +// @allowJs: true +// @Filename: a.js +////function bar() { +////} +////bar.[|foo|] = "foo"; +////console.log(bar./**/[|foo|]); + +goTo.marker(); +verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file From 39b3ecb78c40b88bc277fbdf537e94b46005efc6 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 22 Jan 2017 10:45:23 -0800 Subject: [PATCH 2/6] Handel defining properties on function and class expressions in .js files --- src/compiler/binder.ts | 16 +++++++++--- src/compiler/checker.ts | 7 +++-- src/compiler/utilities.ts | 8 ++---- .../reference/multipleDeclarations.symbols | 26 +++++++++++-------- .../reference/multipleDeclarations.types | 14 +++++----- .../fourslash/getJavaScriptCompletions20.ts | 2 +- .../fourslash/renameJsPropertyAssignment2.ts | 11 ++++++++ .../fourslash/renameJsPropertyAssignment3.ts | 11 ++++++++ .../cases/fourslash/renameJsThisProperty05.ts | 15 +++++++++++ .../cases/fourslash/renameJsThisProperty06.ts | 15 +++++++++++ 10 files changed, 94 insertions(+), 31 deletions(-) create mode 100644 tests/cases/fourslash/renameJsPropertyAssignment2.ts create mode 100644 tests/cases/fourslash/renameJsPropertyAssignment3.ts create mode 100644 tests/cases/fourslash/renameJsThisProperty05.ts create mode 100644 tests/cases/fourslash/renameJsThisProperty06.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index da1ba46653..50e6941490 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -2215,8 +2215,12 @@ namespace ts { constructorFunction.parent = classPrototype; classPrototype.parent = leftSideOfAssignment; - const funcSymbol = container.locals.get(constructorFunction.text); - if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) { + let funcSymbol = container.locals.get(constructorFunction.text); + if (isDeclarationOfFunctionOrClassExpression(funcSymbol)) { + funcSymbol = (funcSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; + } + + if (!funcSymbol || !(funcSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class))) { return; } @@ -2241,8 +2245,12 @@ namespace ts { leftSideOfAssignment.parent = node; target.parent = leftSideOfAssignment; - const funcSymbol = container.locals[target.text]; - if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) { + let funcSymbol = container.locals.get(target.text); + if (isDeclarationOfFunctionOrClassExpression(funcSymbol)) { + funcSymbol = (funcSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; + } + + if (!funcSymbol || !(funcSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class))) { return; } diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 78f67ae438..b7c81c1e0a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -13886,10 +13886,13 @@ namespace ts { // in a JS file // Note:JS inferred classes might come from a variable declaration instead of a function declaration. // In this case, using getResolvedSymbol directly is required to avoid losing the members from the declaration. - const funcSymbol = node.expression.kind === SyntaxKind.Identifier ? + let funcSymbol = node.expression.kind === SyntaxKind.Identifier ? getResolvedSymbol(node.expression as Identifier) : checkExpression(node.expression).symbol; - if (funcSymbol && funcSymbol.members && (funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) { + if (funcSymbol && isDeclarationOfFunctionOrClassExpression(funcSymbol)) { + funcSymbol = getSymbolOfNode((funcSymbol.valueDeclaration).initializer); + } + if (funcSymbol && funcSymbol.members && funcSymbol.flags & SymbolFlags.Function) { return getInferredClassType(funcSymbol); } else if (compilerOptions.noImplicitAny) { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 5cd0746b03..40bfc2302d 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1366,18 +1366,14 @@ namespace ts { * Returns true if the node is a variable declaration whose initializer is a function expression. * This function does not test if the node is in a JavaScript file or not. */ - export function isDeclarationOfFunctionExpression(s: Symbol) { + export function isDeclarationOfFunctionOrClassExpression(s: Symbol) { if (s.valueDeclaration && s.valueDeclaration.kind === SyntaxKind.VariableDeclaration) { const declaration = s.valueDeclaration as VariableDeclaration; - return declaration.initializer && declaration.initializer.kind === SyntaxKind.FunctionExpression; + return declaration.initializer && (declaration.initializer.kind === SyntaxKind.FunctionExpression || declaration.initializer.kind === SyntaxKind.ClassExpression); } return false; } - export function isValidSpecialPropertyAssignmentParent(parentSymbol: Symbol) { - return parentSymbol && (parentSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(parentSymbol)); - } - /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property /// assignments we treat as special in the binder export function getSpecialPropertyAssignmentKind(expression: Node): SpecialPropertyAssignmentKind { diff --git a/tests/baselines/reference/multipleDeclarations.symbols b/tests/baselines/reference/multipleDeclarations.symbols index 9e49c2fc00..4fc8f8a5f2 100644 --- a/tests/baselines/reference/multipleDeclarations.symbols +++ b/tests/baselines/reference/multipleDeclarations.symbols @@ -30,7 +30,7 @@ class X { >this : Symbol(X, Decl(input.js, 5, 1)) this.mistake = 'frankly, complete nonsense'; ->this.mistake : Symbol(X.mistake, Decl(input.js, 12, 5)) +>this.mistake : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) >this : Symbol(X, Decl(input.js, 5, 1)) >mistake : Symbol(X.mistake, Decl(input.js, 8, 35)) } @@ -38,7 +38,7 @@ class X { >m : Symbol(X.m, Decl(input.js, 10, 5)) } mistake() { ->mistake : Symbol(X.mistake, Decl(input.js, 12, 5)) +>mistake : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) } } let x = new X(); @@ -46,9 +46,11 @@ let x = new X(); >X : Symbol(X, Decl(input.js, 5, 1)) X.prototype.mistake = false; ->X.prototype.mistake : Symbol(X.mistake, Decl(input.js, 12, 5)) +>X.prototype.mistake : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) +>X.prototype : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) >X : Symbol(X, Decl(input.js, 5, 1)) >prototype : Symbol(X.prototype) +>mistake : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) x.m(); >x.m : Symbol(X.m, Decl(input.js, 10, 5)) @@ -56,15 +58,15 @@ x.m(); >m : Symbol(X.m, Decl(input.js, 10, 5)) x.mistake; ->x.mistake : Symbol(X.mistake, Decl(input.js, 12, 5)) +>x.mistake : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) >x : Symbol(x, Decl(input.js, 16, 3)) ->mistake : Symbol(X.mistake, Decl(input.js, 12, 5)) +>mistake : Symbol(X.mistake, Decl(input.js, 12, 5), Decl(input.js, 16, 16)) class Y { >Y : Symbol(Y, Decl(input.js, 19, 10)) mistake() { ->mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35)) +>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) } m() { >m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19)) @@ -80,15 +82,17 @@ class Y { >this : Symbol(Y, Decl(input.js, 19, 10)) this.mistake = 'even more nonsense'; ->this.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35)) +>this.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) >this : Symbol(Y, Decl(input.js, 19, 10)) ->mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35)) +>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) } } Y.prototype.mistake = true; ->Y.prototype.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35)) +>Y.prototype.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) +>Y.prototype : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) >Y : Symbol(Y, Decl(input.js, 19, 10)) >prototype : Symbol(Y.prototype) +>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) let y = new Y(); >y : Symbol(y, Decl(input.js, 31, 3)) @@ -100,7 +104,7 @@ y.m(); >m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19)) y.mistake(); ->y.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35)) +>y.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) >y : Symbol(y, Decl(input.js, 31, 3)) ->mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35)) +>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35), Decl(input.js, 29, 1)) diff --git a/tests/baselines/reference/multipleDeclarations.types b/tests/baselines/reference/multipleDeclarations.types index 195bdc2ad0..b82cdbe05e 100644 --- a/tests/baselines/reference/multipleDeclarations.types +++ b/tests/baselines/reference/multipleDeclarations.types @@ -43,16 +43,16 @@ class X { this.mistake = 'frankly, complete nonsense'; >this.mistake = 'frankly, complete nonsense' : "frankly, complete nonsense" ->this.mistake : () => void +>this.mistake : any >this : this ->mistake : () => void +>mistake : any >'frankly, complete nonsense' : "frankly, complete nonsense" } m() { >m : () => void } mistake() { ->mistake : () => void +>mistake : any } } let x = new X(); @@ -62,11 +62,11 @@ let x = new X(); X.prototype.mistake = false; >X.prototype.mistake = false : false ->X.prototype.mistake : () => void +>X.prototype.mistake : any >X.prototype : X >X : typeof X >prototype : X ->mistake : () => void +>mistake : any >false : false x.m(); @@ -76,9 +76,9 @@ x.m(); >m : () => void x.mistake; ->x.mistake : () => void +>x.mistake : any >x : X ->mistake : () => void +>mistake : any class Y { >Y : Y diff --git a/tests/cases/fourslash/getJavaScriptCompletions20.ts b/tests/cases/fourslash/getJavaScriptCompletions20.ts index 3ca27fa288..ec2bcef161 100644 --- a/tests/cases/fourslash/getJavaScriptCompletions20.ts +++ b/tests/cases/fourslash/getJavaScriptCompletions20.ts @@ -18,4 +18,4 @@ //// Person.getNa/**/ = 10; goTo.marker(); -verify.not.completionListContains('getNa'); +verify.completionListContains('getName'); diff --git a/tests/cases/fourslash/renameJsPropertyAssignment2.ts b/tests/cases/fourslash/renameJsPropertyAssignment2.ts new file mode 100644 index 0000000000..39831d4ae1 --- /dev/null +++ b/tests/cases/fourslash/renameJsPropertyAssignment2.ts @@ -0,0 +1,11 @@ +/// + +// @allowJs: true +// @Filename: a.js +////class Minimatch { +////} +////Minimatch.[|staticProperty|] = "string"; +////console.log(Minimatch./**/[|staticProperty|]); + +goTo.marker(); +verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file diff --git a/tests/cases/fourslash/renameJsPropertyAssignment3.ts b/tests/cases/fourslash/renameJsPropertyAssignment3.ts new file mode 100644 index 0000000000..5871010d6f --- /dev/null +++ b/tests/cases/fourslash/renameJsPropertyAssignment3.ts @@ -0,0 +1,11 @@ +/// + +// @allowJs: true +// @Filename: a.js +////var C = class { +////} +////C.[|staticProperty|] = "string"; +////console.log(C./**/[|staticProperty|]); + +goTo.marker(); +verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file diff --git a/tests/cases/fourslash/renameJsThisProperty05.ts b/tests/cases/fourslash/renameJsThisProperty05.ts new file mode 100644 index 0000000000..c1408d6aff --- /dev/null +++ b/tests/cases/fourslash/renameJsThisProperty05.ts @@ -0,0 +1,15 @@ +/// + +// @allowJs: true +// @Filename: a.js +////class C { +//// constructor(y) { +//// this.x = y; +//// } +////} +////C.prototype.[|z|] = 1; +////var t = new C(12); +////t./**/[|z|] = 11; + +goTo.marker(); +verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); diff --git a/tests/cases/fourslash/renameJsThisProperty06.ts b/tests/cases/fourslash/renameJsThisProperty06.ts new file mode 100644 index 0000000000..63a16b68a4 --- /dev/null +++ b/tests/cases/fourslash/renameJsThisProperty06.ts @@ -0,0 +1,15 @@ +/// + +// @allowJs: true +// @Filename: a.js +////var C = class { +//// constructor(y) { +//// this.x = y; +//// } +////} +////C.prototype.[|z|] = 1; +////var t = new C(12); +////t./**/[|z|] = 11; + +goTo.marker(); +verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); From e8a2173feed58a7646092fae0b12fece032878ab Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 22 Jan 2017 10:45:23 -0800 Subject: [PATCH 3/6] Use variable name for class and function expressions names --- src/compiler/checker.ts | 4 +- .../reference/classExpression3.symbols | 6 +-- .../reference/classExpression3.types | 16 ++++---- .../reference/classExpression4.symbols | 6 +-- .../reference/classExpression4.types | 24 +++++------ .../reference/classExpressionES63.symbols | 6 +-- .../reference/classExpressionES63.types | 16 ++++---- .../functionsInClassExpressions.symbols | 24 +++++------ .../functionsInClassExpressions.types | 4 +- .../implementsInClassExpression.symbols | 2 +- .../implementsInClassExpression.types | 4 +- .../staticPropertyNameConflicts.errors.txt | 40 +++++++++---------- .../transformsElideNullUndefinedType.types | 8 ++-- 13 files changed, 81 insertions(+), 79 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b7c81c1e0a..6983191738 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2171,13 +2171,15 @@ namespace ts { return type.flags & TypeFlags.StringLiteral ? `"${escapeString((type).text)}"` : (type).text; } - function getNameOfSymbol(symbol: Symbol): string { if (symbol.declarations && symbol.declarations.length) { const declaration = symbol.declarations[0]; if (declaration.name) { return declarationNameToString(declaration.name); } + if (declaration.parent && declaration.parent.kind === SyntaxKind.VariableDeclaration) { + return declarationNameToString((declaration.parent).name); + } switch (declaration.kind) { case SyntaxKind.ClassExpression: return "(Anonymous class)"; diff --git a/tests/baselines/reference/classExpression3.symbols b/tests/baselines/reference/classExpression3.symbols index bc1b263a00..fbd5f7b533 100644 --- a/tests/baselines/reference/classExpression3.symbols +++ b/tests/baselines/reference/classExpression3.symbols @@ -3,7 +3,7 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; >C : Symbol(C, Decl(classExpression3.ts, 0, 3)) >a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43)) >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53)) ->c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63)) +>c : Symbol(C.c, Decl(classExpression3.ts, 0, 63)) let c = new C(); >c : Symbol(c, Decl(classExpression3.ts, 1, 3)) @@ -20,7 +20,7 @@ c.b; >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53)) c.c; ->c.c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63)) +>c.c : Symbol(C.c, Decl(classExpression3.ts, 0, 63)) >c : Symbol(c, Decl(classExpression3.ts, 1, 3)) ->c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63)) +>c : Symbol(C.c, Decl(classExpression3.ts, 0, 63)) diff --git a/tests/baselines/reference/classExpression3.types b/tests/baselines/reference/classExpression3.types index 51798f300d..713407fa8d 100644 --- a/tests/baselines/reference/classExpression3.types +++ b/tests/baselines/reference/classExpression3.types @@ -1,7 +1,7 @@ === tests/cases/conformance/classes/classExpressions/classExpression3.ts === let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; ->C : typeof (Anonymous class) ->class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof (Anonymous class) +>C : typeof C +>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof C >class extends class { a = 1 } { b = 2 } : (Anonymous class) >class { a = 1 } : (Anonymous class) >a : number @@ -12,22 +12,22 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; >3 : 3 let c = new C(); ->c : (Anonymous class) ->new C() : (Anonymous class) ->C : typeof (Anonymous class) +>c : C +>new C() : C +>C : typeof C c.a; >c.a : number ->c : (Anonymous class) +>c : C >a : number c.b; >c.b : number ->c : (Anonymous class) +>c : C >b : number c.c; >c.c : number ->c : (Anonymous class) +>c : C >c : number diff --git a/tests/baselines/reference/classExpression4.symbols b/tests/baselines/reference/classExpression4.symbols index 4df5302cec..47a03bc4c9 100644 --- a/tests/baselines/reference/classExpression4.symbols +++ b/tests/baselines/reference/classExpression4.symbols @@ -3,7 +3,7 @@ let C = class { >C : Symbol(C, Decl(classExpression4.ts, 0, 3)) foo() { ->foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15)) +>foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15)) return new C(); >C : Symbol(C, Decl(classExpression4.ts, 0, 3)) @@ -11,7 +11,7 @@ let C = class { }; let x = (new C).foo(); >x : Symbol(x, Decl(classExpression4.ts, 5, 3)) ->(new C).foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15)) +>(new C).foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15)) >C : Symbol(C, Decl(classExpression4.ts, 0, 3)) ->foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15)) +>foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15)) diff --git a/tests/baselines/reference/classExpression4.types b/tests/baselines/reference/classExpression4.types index 066f169ae7..849a7459bb 100644 --- a/tests/baselines/reference/classExpression4.types +++ b/tests/baselines/reference/classExpression4.types @@ -1,22 +1,22 @@ === tests/cases/conformance/classes/classExpressions/classExpression4.ts === let C = class { ->C : typeof (Anonymous class) ->class { foo() { return new C(); }} : typeof (Anonymous class) +>C : typeof C +>class { foo() { return new C(); }} : typeof C foo() { ->foo : () => (Anonymous class) +>foo : () => C return new C(); ->new C() : (Anonymous class) ->C : typeof (Anonymous class) +>new C() : C +>C : typeof C } }; let x = (new C).foo(); ->x : (Anonymous class) ->(new C).foo() : (Anonymous class) ->(new C).foo : () => (Anonymous class) ->(new C) : (Anonymous class) ->new C : (Anonymous class) ->C : typeof (Anonymous class) ->foo : () => (Anonymous class) +>x : C +>(new C).foo() : C +>(new C).foo : () => C +>(new C) : C +>new C : C +>C : typeof C +>foo : () => C diff --git a/tests/baselines/reference/classExpressionES63.symbols b/tests/baselines/reference/classExpressionES63.symbols index 4e52d5ee9d..f74b2893f7 100644 --- a/tests/baselines/reference/classExpressionES63.symbols +++ b/tests/baselines/reference/classExpressionES63.symbols @@ -3,7 +3,7 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; >C : Symbol(C, Decl(classExpressionES63.ts, 0, 3)) >a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43)) >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53)) ->c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63)) +>c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63)) let c = new C(); >c : Symbol(c, Decl(classExpressionES63.ts, 1, 3)) @@ -20,7 +20,7 @@ c.b; >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53)) c.c; ->c.c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63)) +>c.c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63)) >c : Symbol(c, Decl(classExpressionES63.ts, 1, 3)) ->c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63)) +>c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63)) diff --git a/tests/baselines/reference/classExpressionES63.types b/tests/baselines/reference/classExpressionES63.types index c5c8de91c1..f597edab9d 100644 --- a/tests/baselines/reference/classExpressionES63.types +++ b/tests/baselines/reference/classExpressionES63.types @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/classExpressions/classExpressionES63.ts === let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; ->C : typeof (Anonymous class) ->class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof (Anonymous class) +>C : typeof C +>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof C >class extends class { a = 1 } { b = 2 } : (Anonymous class) >class { a = 1 } : (Anonymous class) >a : number @@ -12,22 +12,22 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; >3 : 3 let c = new C(); ->c : (Anonymous class) ->new C() : (Anonymous class) ->C : typeof (Anonymous class) +>c : C +>new C() : C +>C : typeof C c.a; >c.a : number ->c : (Anonymous class) +>c : C >a : number c.b; >c.b : number ->c : (Anonymous class) +>c : C >b : number c.c; >c.c : number ->c : (Anonymous class) +>c : C >c : number diff --git a/tests/baselines/reference/functionsInClassExpressions.symbols b/tests/baselines/reference/functionsInClassExpressions.symbols index a1da3a3175..4aa62da8e3 100644 --- a/tests/baselines/reference/functionsInClassExpressions.symbols +++ b/tests/baselines/reference/functionsInClassExpressions.symbols @@ -4,24 +4,24 @@ let Foo = class { constructor() { this.bar++; ->this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) ->this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9)) ->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this.bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9)) +>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) } bar = 0; ->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) inc = () => { ->inc : Symbol((Anonymous class).inc, Decl(functionsInClassExpressions.ts, 4, 12)) +>inc : Symbol(Foo.inc, Decl(functionsInClassExpressions.ts, 4, 12)) this.bar++; ->this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) ->this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9)) ->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this.bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9)) +>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) } m() { return this.bar; } ->m : Symbol((Anonymous class).m, Decl(functionsInClassExpressions.ts, 7, 5)) ->this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) ->this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9)) ->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>m : Symbol(Foo.m, Decl(functionsInClassExpressions.ts, 7, 5)) +>this.bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9)) +>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5)) } diff --git a/tests/baselines/reference/functionsInClassExpressions.types b/tests/baselines/reference/functionsInClassExpressions.types index b00f3df349..7352f6e6b1 100644 --- a/tests/baselines/reference/functionsInClassExpressions.types +++ b/tests/baselines/reference/functionsInClassExpressions.types @@ -1,7 +1,7 @@ === tests/cases/compiler/functionsInClassExpressions.ts === let Foo = class { ->Foo : typeof (Anonymous class) ->class { constructor() { this.bar++; } bar = 0; inc = () => { this.bar++; } m() { return this.bar; }} : typeof (Anonymous class) +>Foo : typeof Foo +>class { constructor() { this.bar++; } bar = 0; inc = () => { this.bar++; } m() { return this.bar; }} : typeof Foo constructor() { this.bar++; diff --git a/tests/baselines/reference/implementsInClassExpression.symbols b/tests/baselines/reference/implementsInClassExpression.symbols index 48a44d91e9..bf3b3ef933 100644 --- a/tests/baselines/reference/implementsInClassExpression.symbols +++ b/tests/baselines/reference/implementsInClassExpression.symbols @@ -11,5 +11,5 @@ let cls = class implements Foo { >Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0)) doThing() { } ->doThing : Symbol((Anonymous class).doThing, Decl(implementsInClassExpression.ts, 4, 32)) +>doThing : Symbol(cls.doThing, Decl(implementsInClassExpression.ts, 4, 32)) } diff --git a/tests/baselines/reference/implementsInClassExpression.types b/tests/baselines/reference/implementsInClassExpression.types index d3647c30ff..0734f8b8b7 100644 --- a/tests/baselines/reference/implementsInClassExpression.types +++ b/tests/baselines/reference/implementsInClassExpression.types @@ -7,8 +7,8 @@ interface Foo { } let cls = class implements Foo { ->cls : typeof (Anonymous class) ->class implements Foo { doThing() { }} : typeof (Anonymous class) +>cls : typeof cls +>class implements Foo { doThing() { }} : typeof cls >Foo : Foo doThing() { } diff --git a/tests/baselines/reference/staticPropertyNameConflicts.errors.txt b/tests/baselines/reference/staticPropertyNameConflicts.errors.txt index 4c051ace0a..1b22bbbf75 100644 --- a/tests/baselines/reference/staticPropertyNameConflicts.errors.txt +++ b/tests/baselines/reference/staticPropertyNameConflicts.errors.txt @@ -9,17 +9,17 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(41,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'. tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(47,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'. tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(52,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(62,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(67,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(73,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(78,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(84,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(62,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(67,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(73,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(78,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(84,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype_Anonymous'. tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(89,12): error TS2300: Duplicate identifier 'prototype'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(89,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(95,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(100,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(106,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'. -tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(111,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(89,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(95,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(100,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(106,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments_Anonymous'. +tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(111,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn_Anonymous'. tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(121,16): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'. tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(128,16): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'. tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(136,16): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'. @@ -119,14 +119,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon var StaticName_Anonymous = class { static name: number; // error ~~~~ -!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName_Anonymous'. name: string; // ok } var StaticNameFn_Anonymous = class { static name() {} // error ~~~~ -!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn_Anonymous'. name() {} // ok } @@ -134,14 +134,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon var StaticLength_Anonymous = class { static length: number; // error ~~~~~~ -!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength_Anonymous'. length: string; // ok } var StaticLengthFn_Anonymous = class { static length() {} // error ~~~~~~ -!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn_Anonymous'. length() {} // ok } @@ -149,7 +149,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon var StaticPrototype_Anonymous = class { static prototype: number; // error ~~~~~~~~~ -!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype_Anonymous'. prototype: string; // ok } @@ -158,7 +158,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon ~~~~~~~~~ !!! error TS2300: Duplicate identifier 'prototype'. ~~~~~~~~~ -!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn_Anonymous'. prototype() {} // ok } @@ -166,14 +166,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon var StaticCaller_Anonymous = class { static caller: number; // error ~~~~~~ -!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller_Anonymous'. caller: string; // ok } var StaticCallerFn_Anonymous = class { static caller() {} // error ~~~~~~ -!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn_Anonymous'. caller() {} // ok } @@ -181,14 +181,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon var StaticArguments_Anonymous = class { static arguments: number; // error ~~~~~~~~~ -!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments_Anonymous'. arguments: string; // ok } var StaticArgumentsFn_Anonymous = class { static arguments() {} // error ~~~~~~~~~ -!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'. +!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn_Anonymous'. arguments() {} // ok } diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.types b/tests/baselines/reference/transformsElideNullUndefinedType.types index 7f48d8a00e..ffc26ddaa6 100644 --- a/tests/baselines/reference/transformsElideNullUndefinedType.types +++ b/tests/baselines/reference/transformsElideNullUndefinedType.types @@ -140,14 +140,14 @@ class C5 { } var C6 = class { constructor(p12: null) { } } ->C6 : typeof (Anonymous class) ->class { constructor(p12: null) { } } : typeof (Anonymous class) +>C6 : typeof C6 +>class { constructor(p12: null) { } } : typeof C6 >p12 : null >null : null var C7 = class { constructor(p13: undefined) { } } ->C7 : typeof (Anonymous class) ->class { constructor(p13: undefined) { } } : typeof (Anonymous class) +>C7 : typeof C7 +>class { constructor(p13: undefined) { } } : typeof C7 >p13 : undefined declare function fn(); From 793d8be6e02a2881b6d7d09cdd662b17ca1b56e7 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Mon, 30 Jan 2017 16:42:12 -0800 Subject: [PATCH 4/6] Check for undefined symbols --- src/compiler/binder.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 50e6941490..e462898a0c 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -2216,7 +2216,7 @@ namespace ts { classPrototype.parent = leftSideOfAssignment; let funcSymbol = container.locals.get(constructorFunction.text); - if (isDeclarationOfFunctionOrClassExpression(funcSymbol)) { + if (funcSymbol && isDeclarationOfFunctionOrClassExpression(funcSymbol)) { funcSymbol = (funcSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; } @@ -2246,7 +2246,7 @@ namespace ts { target.parent = leftSideOfAssignment; let funcSymbol = container.locals.get(target.text); - if (isDeclarationOfFunctionOrClassExpression(funcSymbol)) { + if (funcSymbol && isDeclarationOfFunctionOrClassExpression(funcSymbol)) { funcSymbol = (funcSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; } From 0aa8a6e4a5d54de2f7312915717f7037e65960af Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Mon, 13 Feb 2017 20:54:47 -0800 Subject: [PATCH 5/6] Consolidate bindProperty logic in one function --- src/compiler/binder.ts | 41 +++++++++++++++-------------------------- 1 file changed, 15 insertions(+), 26 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 1453ed2522..b76700bd49 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1928,7 +1928,7 @@ namespace ts { bindThisPropertyAssignment(node); break; case SpecialPropertyAssignmentKind.Property: - bindPropertyAssignment(node); + bindStaticPropertyAssignment(node); break; case SpecialPropertyAssignmentKind.None: // Nothing to do @@ -2220,25 +2220,10 @@ namespace ts { constructorFunction.parent = classPrototype; classPrototype.parent = leftSideOfAssignment; - let funcSymbol = container.locals.get(constructorFunction.text); - if (funcSymbol && isDeclarationOfFunctionOrClassExpression(funcSymbol)) { - funcSymbol = (funcSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; - } - - if (!funcSymbol || !(funcSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class))) { - return; - } - - // Set up the members collection if it doesn't exist already - if (!funcSymbol.members) { - funcSymbol.members = createMap(); - } - - // Declare the method/property - declareSymbol(funcSymbol.members, funcSymbol, leftSideOfAssignment, SymbolFlags.Property, SymbolFlags.PropertyExcludes); + bindPropertyAssignment(constructorFunction.text, leftSideOfAssignment, /*isPrototypeProperty*/ true); } - function bindPropertyAssignment(node: BinaryExpression) { + function bindStaticPropertyAssignment(node: BinaryExpression) { // We saw a node of the form 'x.y = z'. Declare a 'member' y on x if x was a function. // Look up the function in the local scope, since prototype assignments should @@ -2250,22 +2235,26 @@ namespace ts { leftSideOfAssignment.parent = node; target.parent = leftSideOfAssignment; - let funcSymbol = container.locals.get(target.text); - if (funcSymbol && isDeclarationOfFunctionOrClassExpression(funcSymbol)) { - funcSymbol = (funcSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; + bindPropertyAssignment(target.text, leftSideOfAssignment, /*isPrototypeProperty*/ false); + } + + function bindPropertyAssignment(functionName: string, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean) { + let targetSymbol = container.locals.get(functionName); + if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) { + targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; } - if (!funcSymbol || !(funcSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class))) { + if (!targetSymbol || !(targetSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class))) { return; } // Set up the members collection if it doesn't exist already - if (!funcSymbol.exports) { - funcSymbol.exports = createMap(); - } + const symbolTable = isPrototypeProperty ? + (targetSymbol.members || (targetSymbol.members = createMap())): + (targetSymbol.exports || (targetSymbol.exports = createMap())); // Declare the method/property - declareSymbol(funcSymbol.exports, funcSymbol, leftSideOfAssignment, SymbolFlags.Property, SymbolFlags.PropertyExcludes); + declareSymbol(symbolTable, targetSymbol, propertyAccessExpression, SymbolFlags.Property, SymbolFlags.PropertyExcludes); } function bindCallExpression(node: CallExpression) { From 90eef8940ee5bdc584cd82e4773ba083152c199f Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Mon, 13 Feb 2017 20:54:57 -0800 Subject: [PATCH 6/6] accept baseline change --- .../cases/fourslash/findAllRefsForVariableInExtendsClause01.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts b/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts index d40cb009f1..a61f925c97 100644 --- a/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts +++ b/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts @@ -3,4 +3,4 @@ ////var [|{| "isWriteAccess": true, "isDefinition": true |}Base|] = class { }; ////class C extends [|Base|] { } -verify.singleReferenceGroup("var Base: typeof (Anonymous class)"); +verify.singleReferenceGroup("var Base: typeof Base");