mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-11-18 20:11:14 +00:00
Support some late-bound special property assignments (#33220)
* Support some late-bound special property assignments * Integrate PR feedback * PR feedback * Enable declaration on core tests * Specialize type of binary expression used for late binding, speculative fix to navigation bar, merge check and type for elem/property accesses * Add test showing current nav bar behavior (specifically the lack thereof)
This commit is contained in:
1 parent
304fcee09b
commit
293816875c
51 files changed
+1897
-47
No files matched your search
+32
-3
@@ -2622,7 +2622,12 @@ namespace ts {
|
||||
// Declare a 'member' if the container is an ES5 class or ES6 constructor
|
||||
constructorSymbol.members = constructorSymbol.members || createSymbolTable();
|
||||
// It's acceptable for multiple 'this' assignments of the same identifier to occur
|
||||
declareSymbol(constructorSymbol.members, constructorSymbol, node, SymbolFlags.Property | SymbolFlags.Assignment, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
|
||||
if (hasDynamicName(node)) {
|
||||
bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol);
|
||||
}
|
||||
else {
|
||||
declareSymbol(constructorSymbol.members, constructorSymbol, node, SymbolFlags.Property | SymbolFlags.Assignment, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
|
||||
}
|
||||
addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, SymbolFlags.Class);
|
||||
}
|
||||
break;
|
||||
@@ -2636,7 +2641,12 @@ namespace ts {
|
||||
// Bind this property to the containing class
|
||||
const containingClass = thisContainer.parent;
|
||||
const symbolTable = hasModifier(thisContainer, ModifierFlags.Static) ? containingClass.symbol.exports! : containingClass.symbol.members!;
|
||||
declareSymbol(symbolTable, containingClass.symbol, node, SymbolFlags.Property | SymbolFlags.Assignment, SymbolFlags.None, /*isReplaceableByMethod*/ true);
|
||||
if (hasDynamicName(node)) {
|
||||
bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol);
|
||||
}
|
||||
else {
|
||||
declareSymbol(symbolTable, containingClass.symbol, node, SymbolFlags.Property | SymbolFlags.Assignment, SymbolFlags.None, /*isReplaceableByMethod*/ true);
|
||||
}
|
||||
break;
|
||||
case SyntaxKind.SourceFile:
|
||||
// this.property = assignment in a source file -- declare symbol in exports for a module, in locals for a script
|
||||
@@ -2653,6 +2663,18 @@ namespace ts {
|
||||
}
|
||||
}
|
||||
|
||||
function bindDynamicallyNamedThisPropertyAssignment(node: BinaryExpression | DynamicNamedDeclaration, symbol: Symbol) {
|
||||
bindAnonymousDeclaration(node, SymbolFlags.Property, InternalSymbolName.Computed);
|
||||
addLateBoundAssignmentDeclarationToSymbol(node, symbol);
|
||||
}
|
||||
|
||||
function addLateBoundAssignmentDeclarationToSymbol(node: BinaryExpression | DynamicNamedDeclaration, symbol: Symbol | undefined) {
|
||||
if (symbol) {
|
||||
const members = symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = createMap());
|
||||
members.set("" + getNodeId(node), node);
|
||||
}
|
||||
}
|
||||
|
||||
function bindSpecialPropertyDeclaration(node: PropertyAccessExpression) {
|
||||
if (node.expression.kind === SyntaxKind.ThisKeyword) {
|
||||
bindThisPropertyAssignment(node);
|
||||
@@ -2722,7 +2744,14 @@ namespace ts {
|
||||
bindExportsPropertyAssignment(node);
|
||||
}
|
||||
else {
|
||||
bindStaticPropertyAssignment(lhs);
|
||||
if (hasDynamicName(node)) {
|
||||
bindAnonymousDeclaration(node, SymbolFlags.Property | SymbolFlags.Assignment, InternalSymbolName.Computed);
|
||||
const sym = bindPotentiallyMissingNamespaces(parentSymbol, lhs.expression, isTopLevelNamespaceAssignment(lhs), /*isPrototype*/ false, /*containerIsClass*/ false);
|
||||
addLateBoundAssignmentDeclarationToSymbol(node, sym);
|
||||
}
|
||||
else {
|
||||
bindStaticPropertyAssignment(lhs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+44
-16
@@ -2860,7 +2860,7 @@ namespace ts {
|
||||
}
|
||||
|
||||
function getExportsOfSymbol(symbol: Symbol): SymbolTable {
|
||||
return symbol.flags & SymbolFlags.Class ? getResolvedMembersOrExportsOfSymbol(symbol, MembersOrExportsResolutionKind.resolvedExports) :
|
||||
return symbol.flags & SymbolFlags.LateBindingContainer ? getResolvedMembersOrExportsOfSymbol(symbol, MembersOrExportsResolutionKind.resolvedExports) :
|
||||
symbol.flags & SymbolFlags.Module ? getExportsOfModule(symbol) :
|
||||
symbol.exports || emptySymbols;
|
||||
}
|
||||
@@ -4224,7 +4224,15 @@ namespace ts {
|
||||
if (context.tracker.trackSymbol && getCheckFlags(propertySymbol) & CheckFlags.Late) {
|
||||
const decl = first(propertySymbol.declarations);
|
||||
if (hasLateBindableName(decl)) {
|
||||
trackComputedName(decl.name, saveEnclosingDeclaration, context);
|
||||
if (isBinaryExpression(decl)) {
|
||||
const name = getNameOfDeclaration(decl);
|
||||
if (name && isElementAccessExpression(name) && isPropertyAccessEntityNameExpression(name.argumentExpression)) {
|
||||
trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
|
||||
}
|
||||
}
|
||||
else {
|
||||
trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
|
||||
}
|
||||
}
|
||||
}
|
||||
const propertyName = symbolToName(propertySymbol, context, SymbolFlags.Value, /*expectsIdentifier*/ true);
|
||||
@@ -4440,7 +4448,7 @@ namespace ts {
|
||||
return <BindingName>elideInitializerAndSetEmitFlags(node);
|
||||
function elideInitializerAndSetEmitFlags(node: Node): Node {
|
||||
if (context.tracker.trackSymbol && isComputedPropertyName(node) && isLateBindableName(node)) {
|
||||
trackComputedName(node, context.enclosingDeclaration, context);
|
||||
trackComputedName(node.expression, context.enclosingDeclaration, context);
|
||||
}
|
||||
const visited = visitEachChild(node, elideInitializerAndSetEmitFlags, nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags)!;
|
||||
const clone = nodeIsSynthesized(visited) ? visited : getSynthesizedClone(visited);
|
||||
@@ -4452,10 +4460,10 @@ namespace ts {
|
||||
}
|
||||
}
|
||||
|
||||
function trackComputedName(node: LateBoundName, enclosingDeclaration: Node | undefined, context: NodeBuilderContext) {
|
||||
function trackComputedName(accessExpression: EntityNameOrEntityNameExpression, enclosingDeclaration: Node | undefined, context: NodeBuilderContext) {
|
||||
if (!context.tracker.trackSymbol) return;
|
||||
// get symbol of the first identifier of the entityName
|
||||
const firstIdentifier = getFirstIdentifier(node.expression);
|
||||
const firstIdentifier = getFirstIdentifier(accessExpression);
|
||||
const name = resolveName(firstIdentifier, firstIdentifier.escapedText, SymbolFlags.Value | SymbolFlags.ExportValue, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true);
|
||||
if (name) {
|
||||
context.tracker.trackSymbol(name, enclosingDeclaration, SymbolFlags.Value);
|
||||
@@ -7182,8 +7190,10 @@ namespace ts {
|
||||
if (declaration.kind === SyntaxKind.ExportAssignment) {
|
||||
type = widenTypeForVariableLikeDeclaration(checkExpressionCached((<ExportAssignment>declaration).expression), declaration);
|
||||
}
|
||||
else if (isInJSFile(declaration) &&
|
||||
(isCallExpression(declaration) || isBinaryExpression(declaration) || isPropertyAccessExpression(declaration) && isBinaryExpression(declaration.parent))) {
|
||||
else if (
|
||||
isBinaryExpression(declaration) ||
|
||||
(isInJSFile(declaration) &&
|
||||
(isCallExpression(declaration) || isPropertyAccessExpression(declaration) && isBinaryExpression(declaration.parent)))) {
|
||||
type = getWidenedTypeForAssignmentDeclaration(symbol);
|
||||
}
|
||||
else if (isJSDocPropertyLikeTag(declaration)
|
||||
@@ -8201,9 +8211,12 @@ namespace ts {
|
||||
* - The type of its expression is a string or numeric literal type, or is a `unique symbol` type.
|
||||
*/
|
||||
function isLateBindableName(node: DeclarationName): node is LateBoundName {
|
||||
return isComputedPropertyName(node)
|
||||
&& isEntityNameExpression(node.expression)
|
||||
&& isTypeUsableAsPropertyName(checkComputedPropertyName(node));
|
||||
if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
|
||||
return false;
|
||||
}
|
||||
const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
|
||||
return isEntityNameExpression(expr)
|
||||
&& isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
|
||||
}
|
||||
|
||||
function isLateBoundName(name: __String): boolean {
|
||||
@@ -8215,7 +8228,7 @@ namespace ts {
|
||||
/**
|
||||
* Indicates whether a declaration has a late-bindable dynamic name.
|
||||
*/
|
||||
function hasLateBindableName(node: Declaration): node is LateBoundDeclaration {
|
||||
function hasLateBindableName(node: Declaration): node is LateBoundDeclaration | LateBoundBinaryExpressionDeclaration {
|
||||
const name = getNameOfDeclaration(node);
|
||||
return !!name && isLateBindableName(name);
|
||||
}
|
||||
@@ -8252,7 +8265,7 @@ namespace ts {
|
||||
* late-bound members that `addDeclarationToSymbol` in binder.ts performs for early-bound
|
||||
* members.
|
||||
*/
|
||||
function addDeclarationToLateBoundSymbol(symbol: Symbol, member: LateBoundDeclaration, symbolFlags: SymbolFlags) {
|
||||
function addDeclarationToLateBoundSymbol(symbol: Symbol, member: LateBoundDeclaration | BinaryExpression, symbolFlags: SymbolFlags) {
|
||||
Debug.assert(!!(getCheckFlags(symbol) & CheckFlags.Late), "Expected a late-bound symbol.");
|
||||
symbol.flags |= symbolFlags;
|
||||
getSymbolLinks(member.symbol).lateSymbol = symbol;
|
||||
@@ -8297,14 +8310,15 @@ namespace ts {
|
||||
* @param lateSymbols The late-bound symbols of the parent.
|
||||
* @param decl The member to bind.
|
||||
*/
|
||||
function lateBindMember(parent: Symbol, earlySymbols: SymbolTable | undefined, lateSymbols: SymbolTable, decl: LateBoundDeclaration) {
|
||||
function lateBindMember(parent: Symbol, earlySymbols: SymbolTable | undefined, lateSymbols: SymbolTable, decl: LateBoundDeclaration | LateBoundBinaryExpressionDeclaration) {
|
||||
Debug.assert(!!decl.symbol, "The member is expected to have a symbol.");
|
||||
const links = getNodeLinks(decl);
|
||||
if (!links.resolvedSymbol) {
|
||||
// In the event we attempt to resolve the late-bound name of this member recursively,
|
||||
// fall back to the early-bound name of this member.
|
||||
links.resolvedSymbol = decl.symbol;
|
||||
const type = checkComputedPropertyName(decl.name);
|
||||
const declName = isBinaryExpression(decl) ? decl.left : decl.name;
|
||||
const type = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
|
||||
if (isTypeUsableAsPropertyName(type)) {
|
||||
const memberName = getPropertyNameFromType(type);
|
||||
const symbolFlags = decl.symbol.flags;
|
||||
@@ -8321,9 +8335,9 @@ namespace ts {
|
||||
// If we have an existing early-bound member, combine its declarations so that we can
|
||||
// report an error at each declaration.
|
||||
const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
|
||||
const name = !(type.flags & TypeFlags.UniqueESSymbol) && unescapeLeadingUnderscores(memberName) || declarationNameToString(decl.name);
|
||||
const name = !(type.flags & TypeFlags.UniqueESSymbol) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
|
||||
forEach(declarations, declaration => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
|
||||
error(decl.name || decl, Diagnostics.Duplicate_property_0, name);
|
||||
error(declName || decl, Diagnostics.Duplicate_property_0, name);
|
||||
lateSymbol = createSymbol(SymbolFlags.None, memberName, CheckFlags.Late);
|
||||
}
|
||||
lateSymbol.nameType = type;
|
||||
@@ -8365,6 +8379,20 @@ namespace ts {
|
||||
}
|
||||
}
|
||||
}
|
||||
const assignments = symbol.assignmentDeclarationMembers;
|
||||
if (assignments) {
|
||||
const decls = arrayFrom(assignments.values());
|
||||
for (const member of decls) {
|
||||
const assignmentKind = getAssignmentDeclarationKind(member as BinaryExpression | CallExpression);
|
||||
const isInstanceMember = assignmentKind === AssignmentDeclarationKind.PrototypeProperty
|
||||
|| assignmentKind === AssignmentDeclarationKind.ThisProperty
|
||||
|| assignmentKind === AssignmentDeclarationKind.ObjectDefinePrototypeProperty
|
||||
|| assignmentKind === AssignmentDeclarationKind.Prototype; // A straight `Prototype` assignment probably can never have a computed name
|
||||
if (isStatic === !isInstanceMember && hasLateBindableName(member)) {
|
||||
lateBindMember(symbol, earlySymbols, lateSymbols, member);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols;
|
||||
}
|
||||
|
||||
@@ -1130,7 +1130,7 @@ namespace ts {
|
||||
fakespace.symbol = props[0].parent!;
|
||||
const declarations = mapDefined(props, p => {
|
||||
if (!isPropertyAccessExpression(p.valueDeclaration)) {
|
||||
return undefined;
|
||||
return undefined; // TODO GH#33569: Handle element access expressions that created late bound names (rather than silently omitting them)
|
||||
}
|
||||
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
|
||||
const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, symbolTracker);
|
||||
|
||||
+18
-2
@@ -814,7 +814,7 @@ namespace ts {
|
||||
|
||||
export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
|
||||
|
||||
export type DeclarationName = Identifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | BindingPattern;
|
||||
export type DeclarationName = Identifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern;
|
||||
|
||||
export interface Declaration extends Node {
|
||||
_declarationBrand: any;
|
||||
@@ -829,12 +829,27 @@ namespace ts {
|
||||
name: ComputedPropertyName;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export interface DynamicNamedBinaryExpression extends BinaryExpression {
|
||||
left: ElementAccessExpression;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
// A declaration that supports late-binding (used in checker)
|
||||
export interface LateBoundDeclaration extends DynamicNamedDeclaration {
|
||||
name: LateBoundName;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export interface LateBoundBinaryExpressionDeclaration extends DynamicNamedBinaryExpression {
|
||||
left: LateBoundElementAccessExpression;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export interface LateBoundElementAccessExpression extends ElementAccessExpression {
|
||||
argumentExpression: EntityNameExpression;
|
||||
}
|
||||
|
||||
export interface DeclarationStatement extends NamedDeclaration, Statement {
|
||||
name?: Identifier | StringLiteral | NumericLiteral;
|
||||
}
|
||||
@@ -3828,7 +3843,7 @@ namespace ts {
|
||||
Classifiable = Class | Enum | TypeAlias | Interface | TypeParameter | Module | Alias,
|
||||
|
||||
/* @internal */
|
||||
LateBindingContainer = Class | Interface | TypeLiteral | ObjectLiteral,
|
||||
LateBindingContainer = Class | Interface | TypeLiteral | ObjectLiteral | Function,
|
||||
}
|
||||
|
||||
export interface Symbol {
|
||||
@@ -3848,6 +3863,7 @@ namespace ts {
|
||||
/* @internal */ isReferenced?: SymbolFlags; // True if the symbol is referenced elsewhere. Keeps track of the meaning of a reference in case a symbol is both a type parameter and parameter.
|
||||
/* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
|
||||
/* @internal */ isAssigned?: boolean; // True if the symbol is a parameter with assignments
|
||||
/* @internal */ assignmentDeclarationMembers?: Map<Declaration>; // detected late-bound assignment declarations associated with the symbol
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
|
||||
+50
-15
@@ -2060,19 +2060,51 @@ namespace ts {
|
||||
}
|
||||
return AssignmentDeclarationKind.ObjectDefinePropertyValue;
|
||||
}
|
||||
if (expr.operatorToken.kind !== SyntaxKind.EqualsToken ||
|
||||
!isPropertyAccessExpression(expr.left)) {
|
||||
if (expr.operatorToken.kind !== SyntaxKind.EqualsToken) {
|
||||
return AssignmentDeclarationKind.None;
|
||||
}
|
||||
const lhs = expr.left;
|
||||
if (isEntityNameExpression(lhs.expression) && lhs.name.escapedText === "prototype" && isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) {
|
||||
// F.prototype = { ... }
|
||||
return AssignmentDeclarationKind.Prototype;
|
||||
if (isAccessExpression(lhs)) {
|
||||
if (isEntityNameExpression(lhs.expression) && getElementOrPropertyAccessName(lhs) === "prototype" && isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) {
|
||||
// F.prototype = { ... }
|
||||
return AssignmentDeclarationKind.Prototype;
|
||||
}
|
||||
return getAssignmentDeclarationPropertyAccessKind(lhs);
|
||||
}
|
||||
return getAssignmentDeclarationPropertyAccessKind(lhs);
|
||||
return AssignmentDeclarationKind.None;
|
||||
}
|
||||
|
||||
export function getAssignmentDeclarationPropertyAccessKind(lhs: PropertyAccessExpression): AssignmentDeclarationKind {
|
||||
/**
|
||||
* Does not handle signed numeric names like `a[+0]` - handling those would require handling prefix unary expressions
|
||||
* throughout late binding handling as well, which is awkward (but ultimately probably doable if there is demand)
|
||||
*/
|
||||
/* @internal */
|
||||
export function getElementOrPropertyAccessArgumentExpressionOrName(node: AccessExpression): Identifier | StringLiteralLike | NumericLiteral | ElementAccessExpression | undefined {
|
||||
if (isPropertyAccessExpression(node)) {
|
||||
return node.name;
|
||||
}
|
||||
const arg = skipParentheses(node.argumentExpression);
|
||||
if (isNumericLiteral(arg) || isStringLiteralLike(arg)) {
|
||||
return arg;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export function getElementOrPropertyAccessName(node: AccessExpression): string | undefined {
|
||||
const name = getElementOrPropertyAccessArgumentExpressionOrName(node);
|
||||
if (name) {
|
||||
if (isIdentifier(name)) {
|
||||
return idText(name);
|
||||
}
|
||||
if (isStringLiteralLike(name) || isNumericLiteral(name)) {
|
||||
return name.text;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function getAssignmentDeclarationPropertyAccessKind(lhs: AccessExpression): AssignmentDeclarationKind {
|
||||
if (lhs.expression.kind === SyntaxKind.ThisKeyword) {
|
||||
return AssignmentDeclarationKind.ThisProperty;
|
||||
}
|
||||
@@ -2087,13 +2119,13 @@ namespace ts {
|
||||
}
|
||||
|
||||
let nextToLast = lhs;
|
||||
while (isPropertyAccessExpression(nextToLast.expression)) {
|
||||
while (isAccessExpression(nextToLast.expression)) {
|
||||
nextToLast = nextToLast.expression;
|
||||
}
|
||||
Debug.assert(isIdentifier(nextToLast.expression));
|
||||
const id = nextToLast.expression as Identifier;
|
||||
if (id.escapedText === "exports" ||
|
||||
id.escapedText === "module" && nextToLast.name.escapedText === "exports") {
|
||||
id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") {
|
||||
// exports.name = expr OR module.exports.name = expr
|
||||
return AssignmentDeclarationKind.ExportsProperty;
|
||||
}
|
||||
@@ -2807,16 +2839,19 @@ namespace ts {
|
||||
* is a property of the Symbol constructor that denotes a built-in
|
||||
* Symbol.
|
||||
*/
|
||||
export function hasDynamicName(declaration: Declaration): declaration is DynamicNamedDeclaration {
|
||||
export function hasDynamicName(declaration: Declaration): declaration is DynamicNamedDeclaration | DynamicNamedBinaryExpression {
|
||||
const name = getNameOfDeclaration(declaration);
|
||||
return !!name && isDynamicName(name);
|
||||
}
|
||||
|
||||
export function isDynamicName(name: DeclarationName): boolean {
|
||||
return name.kind === SyntaxKind.ComputedPropertyName &&
|
||||
!isStringOrNumericLiteralLike(name.expression) &&
|
||||
!isSignedNumericLiteral(name.expression) &&
|
||||
!isWellKnownSymbolSyntactically(name.expression);
|
||||
if (!(name.kind === SyntaxKind.ComputedPropertyName || name.kind === SyntaxKind.ElementAccessExpression)) {
|
||||
return false;
|
||||
}
|
||||
const expr = isElementAccessExpression(name) ? name.argumentExpression : name.expression;
|
||||
return !isStringOrNumericLiteralLike(expr) &&
|
||||
!isSignedNumericLiteral(expr) &&
|
||||
!isWellKnownSymbolSyntactically(expr);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -5299,7 +5334,7 @@ namespace ts {
|
||||
case AssignmentDeclarationKind.ThisProperty:
|
||||
case AssignmentDeclarationKind.Property:
|
||||
case AssignmentDeclarationKind.PrototypeProperty:
|
||||
return ((expr as BinaryExpression).left as PropertyAccessExpression).name;
|
||||
return getElementOrPropertyAccessArgumentExpressionOrName((expr as BinaryExpression).left as AccessExpression);
|
||||
case AssignmentDeclarationKind.ObjectDefinePropertyValue:
|
||||
case AssignmentDeclarationKind.ObjectDefinePropertyExports:
|
||||
case AssignmentDeclarationKind.ObjectDefinePrototypeProperty:
|
||||
|
||||
@@ -55,7 +55,7 @@ namespace ts.FindAllReferences {
|
||||
if (isInJSFile(node)) {
|
||||
const binaryExpression = isBinaryExpression(node.parent) ?
|
||||
node.parent :
|
||||
isPropertyAccessExpression(node.parent) &&
|
||||
isAccessExpression(node.parent) &&
|
||||
isBinaryExpression(node.parent.parent) &&
|
||||
node.parent.parent.left === node.parent ?
|
||||
node.parent.parent :
|
||||
|
||||
@@ -665,7 +665,9 @@ namespace ts.NavigationBar {
|
||||
}
|
||||
|
||||
if (name) {
|
||||
const text = isIdentifier(name) ? name.text : nodeText(name);
|
||||
const text = isIdentifier(name) ? name.text
|
||||
: isElementAccessExpression(name) ? `[${nodeText(name.argumentExpression)}]`
|
||||
: nodeText(name);
|
||||
if (text.length > 0) {
|
||||
return cleanText(text);
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user