From 5f00c7cdbcce0e30ef0eb742f3a0d6417d32703d Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Sat, 29 Nov 2014 17:25:52 -0800 Subject: [PATCH] Change the names for property access and qualified names to match their types. --- src/compiler/checker.ts | 28 ++++++++++++++++------------ src/compiler/emitter.ts | 8 ++++---- src/compiler/parser.ts | 12 ++++++------ src/compiler/types.ts | 6 +++--- src/services/services.ts | 13 ++++++++----- 5 files changed, 37 insertions(+), 30 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c517a3aee45..40cd45e7e4d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5118,7 +5118,7 @@ module ts { return s.valueDeclaration ? s.valueDeclaration.flags : s.flags & SymbolFlags.Prototype ? NodeFlags.Public | NodeFlags.Static : 0; } - function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, type: Type, prop: Symbol) { + function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol) { var flags = getDeclarationFlagsFromSymbol(prop); // Public properties are always accessible if (!(flags & (NodeFlags.Private | NodeFlags.Protected))) { @@ -5138,7 +5138,7 @@ module ts { } // Property is known to be protected at this point // All protected properties of a supertype are accessible in a super access - if (node.left.kind === SyntaxKind.SuperKeyword) { + if (left.kind === SyntaxKind.SuperKeyword) { return; } // A protected property is accessible in the declaring class and classes derived from it @@ -5157,7 +5157,7 @@ module ts { } function checkPropertyAccessExpression(node: PropertyAccessExpression) { - return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); + return checkPropertyAccessExpressionOrQualifiedName(node, node.expression, node.name); } function checkQualifiedName(node: QualifiedName) { @@ -5193,7 +5193,7 @@ module ts { error(right, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { - checkClassPropertyAccess(node, type, prop); + checkClassPropertyAccess(node, left, type, prop); } } return getTypeOfSymbol(prop); @@ -5201,17 +5201,21 @@ module ts { return anyType; } - function isValidPropertyAccess(node: PropertyAccessExpression, propertyName: string): boolean { - var type = checkExpression(node.left); + function isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean { + var left = node.kind === SyntaxKind.PropertyAccessExpression + ? (node).expression + : (node).left; + + var type = checkExpression(left); if (type !== unknownType && type !== anyType) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & SymbolFlags.Class) { - if (node.left.kind === SyntaxKind.SuperKeyword && getDeclarationKindFromSymbol(prop) !== SyntaxKind.Method) { + if (left.kind === SyntaxKind.SuperKeyword && getDeclarationKindFromSymbol(prop) !== SyntaxKind.Method) { return false; } else { var diagnosticsCount = diagnostics.length; - checkClassPropertyAccess(node, type, prop); + checkClassPropertyAccess(node, left, type, prop); return diagnostics.length === diagnosticsCount } } @@ -6535,7 +6539,7 @@ module ts { // - 'object' in indexed access // - target in rhs of import statement var ok = - (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).left === node) || + (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).expression === node) || (node.parent.kind === SyntaxKind.ElementAccessExpression && (node.parent).expression === node) || ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(node)); @@ -8176,8 +8180,8 @@ module ts { propertyName = ((e).argumentExpression).text; } else { - var enumType = getTypeOfNode((e).left); - propertyName = (e).right.text; + var enumType = getTypeOfNode((e).expression); + propertyName = (e).name.text; } if (enumType !== currentType) { return undefined; @@ -8818,7 +8822,7 @@ module ts { function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) { return (node.parent.kind === SyntaxKind.QualifiedName && (node.parent).right === node) || - (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).right === node); + (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).name === node); } function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol { diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 380a4bb3c52..55d5ffd2973 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2252,7 +2252,7 @@ module ts { function tryEmitConstantValue(node: PropertyAccessExpression | ElementAccessExpression): boolean { var constantValue = resolver.getConstantValue(node); if (constantValue !== undefined) { - var propertyName = node.kind === SyntaxKind.PropertyAccessExpression ? declarationNameToString((node).right) : getTextOfNode((node).argumentExpression); + var propertyName = node.kind === SyntaxKind.PropertyAccessExpression ? declarationNameToString((node).name) : getTextOfNode((node).argumentExpression); write(constantValue.toString() + " /* " + propertyName + " */"); return true; } @@ -2263,9 +2263,9 @@ module ts { if (tryEmitConstantValue(node)) { return; } - emit(node.left); + emit(node.expression); write("."); - emit(node.right); + emit(node.name); } function emitQualifiedName(node: QualifiedName) { @@ -2292,7 +2292,7 @@ module ts { } else { emit(node.expression); - superCall = node.expression.kind === SyntaxKind.PropertyAccessExpression && (node.expression).left.kind === SyntaxKind.SuperKeyword; + superCall = node.expression.kind === SyntaxKind.PropertyAccessExpression && (node.expression).expression.kind === SyntaxKind.SuperKeyword; } if (superCall) { write(".call("); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 8a9f6c4e80a..a1be014acc8 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -260,8 +260,8 @@ module ts { case SyntaxKind.ObjectLiteralExpression: return children((node).properties); case SyntaxKind.PropertyAccessExpression: - return child((node).left) || - child((node).right); + return child((node).expression) || + child((node).name); case SyntaxKind.ElementAccessExpression: return child((node).expression) || child((node).argumentExpression); @@ -2811,9 +2811,9 @@ module ts { // If we have seen "super" it must be followed by '(' or '.'. // If it wasn't then just try to parse out a '.' and report an error. var node = createNode(SyntaxKind.PropertyAccessExpression, expression.pos); - node.left = expression; + node.expression = expression; parseExpected(SyntaxKind.DotToken, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); - node.right = parseIdentifierName(); + node.name = parseIdentifierName(); return finishNode(node); } @@ -2863,8 +2863,8 @@ module ts { } } - propertyAccess.left = expression; - propertyAccess.right = id || parseIdentifierName(); + propertyAccess.expression = expression; + propertyAccess.name = id || parseIdentifierName(); expression = finishNode(propertyAccess); continue; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 6fcfc1ba54d..b559fee1af1 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -543,8 +543,8 @@ module ts { } export interface PropertyAccessExpression extends MemberExpression { - left: LeftHandSideExpression; - right: Identifier; + expression: LeftHandSideExpression; + name: Identifier; } export interface ElementAccessExpression extends MemberExpression { @@ -834,7 +834,7 @@ module ts { isEmitBlocked(sourceFile?: SourceFile): boolean; // Returns the constant value of this enum member, or 'undefined' if the enum member has a computed value. getEnumMemberValue(node: EnumMember): number; - isValidPropertyAccess(node: PropertyAccessExpression, propertyName: string): boolean; + isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; getAliasedSymbol(symbol: Symbol): Symbol; } diff --git a/src/services/services.ts b/src/services/services.ts index 04acf4837b3..7ab9c6a41e9 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1927,7 +1927,7 @@ module ts { } function isRightSideOfPropertyAccess(node: Node) { - return node && node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).right === node; + return node && node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).name === node; } function isCallExpressionTarget(node: Node): boolean { @@ -2373,9 +2373,12 @@ module ts { // other wise, it is a request for all visible symbols in the scope, and the node is the current location var node: Node; var isRightOfDot: boolean; - if (previousToken && previousToken.kind === SyntaxKind.DotToken && - (previousToken.parent.kind === SyntaxKind.PropertyAccessExpression || previousToken.parent.kind === SyntaxKind.QualifiedName)) { - node = (previousToken.parent).left; + if (previousToken && previousToken.kind === SyntaxKind.DotToken && previousToken.parent.kind === SyntaxKind.PropertyAccessExpression) { + node = (previousToken.parent).expression; + isRightOfDot = true; + } + else if (previousToken && previousToken.kind === SyntaxKind.DotToken && previousToken.parent.kind === SyntaxKind.QualifiedName) { + node = (previousToken.parent).left; isRightOfDot = true; } else { @@ -2879,7 +2882,7 @@ module ts { var type = typeResolver.getNarrowedTypeOfSymbol(symbol, location); if (type) { if (location.parent && location.parent.kind === SyntaxKind.PropertyAccessExpression) { - var right = (location.parent).right; + var right = (location.parent).name; // Either the location is on the right of a property access, or on the left and the right is missing if (right === location || (right && right.kind === SyntaxKind.Missing)){ location = location.parent;