From e1011aa2f08b7442afa1f7cf1dfa7c4168f0c521 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 29 Nov 2014 15:47:02 -0800
Subject: [PATCH] Rename syntax properties to match Roslyn/Fidelity naming.

---
 src/compiler/checker.ts     | 66 ++++++++++++++++++-------------------
 src/compiler/emitter.ts     | 34 +++++++++----------
 src/compiler/parser.ts      | 46 +++++++++++++-------------
 src/compiler/types.ts       | 14 ++++----
 src/harness/typeWriter.ts   |  2 +-
 src/services/breakpoints.ts |  4 +--
 src/services/services.ts    | 10 +++---
 7 files changed, 88 insertions(+), 88 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ded46d3f19b..4f1f796e3e3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4328,7 +4328,7 @@ module ts {
                     case SyntaxKind.ArrayLiteral:
                     case SyntaxKind.ObjectLiteral:
                     case SyntaxKind.PropertyAccess:
-                    case SyntaxKind.IndexedAccess:
+                    case SyntaxKind.ElementAccessExpression:
                     case SyntaxKind.CallExpression:
                     case SyntaxKind.NewExpression:
                     case SyntaxKind.TypeAssertion:
@@ -4625,7 +4625,7 @@ module ts {
         }
 
         function checkSuperExpression(node: Node): Type {
-            var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).func === node;
+            var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
             var enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
             var baseClass: Type;
             if (enclosingClass && enclosingClass.baseType) {
@@ -5208,15 +5208,15 @@ module ts {
             return true;
         }
 
-        function checkIndexedAccess(node: IndexedAccess): Type {
+        function checkIndexedAccess(node: ElementAccessExpression): Type {
             // Obtain base constraint such that we can bail out if the constraint is an unknown type
-            var objectType = getApparentType(checkExpression(node.object));
-            var indexType = checkExpression(node.index);
+            var objectType = getApparentType(checkExpression(node.expression));
+            var indexType = checkExpression(node.argumentExpression);
 
             if (objectType === unknownType) return unknownType;
 
-            if (isConstEnumObjectType(objectType) && node.index.kind !== SyntaxKind.StringLiteral) {
-                error(node.index, Diagnostics.Index_expression_arguments_in_const_enums_must_be_of_type_string);
+            if (isConstEnumObjectType(objectType) && node.argumentExpression.kind !== SyntaxKind.StringLiteral) {
+                error(node.argumentExpression, Diagnostics.Index_expression_arguments_in_const_enums_must_be_of_type_string);
             }
 
             // TypeScript 1.0 spec (April 2014): 4.10 Property Access
@@ -5229,8 +5229,8 @@ module ts {
             // - Otherwise, if IndexExpr is of type Any, the String or Number primitive type, or an enum type, the property access is of type Any.
 
             // See if we can index as a property.
-            if (node.index.kind === SyntaxKind.StringLiteral || node.index.kind === SyntaxKind.NumericLiteral) {
-                var name = (<LiteralExpression>node.index).text;
+            if (node.argumentExpression.kind === SyntaxKind.StringLiteral || node.argumentExpression.kind === SyntaxKind.NumericLiteral) {
+                var name = (<LiteralExpression>node.argumentExpression).text;
                 var prop = getPropertyOfType(objectType, name);
                 if (prop) {
                     getNodeLinks(node).resolvedSymbol = prop;
@@ -5629,7 +5629,7 @@ module ts {
                         Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
                         typeToString(failedTypeParameter));
 
-                    reportNoCommonSupertypeError(inferenceCandidates, (<CallExpression>node).func || (<TaggedTemplateExpression>node).tag, diagnosticChainHead);
+                    reportNoCommonSupertypeError(inferenceCandidates, (<CallExpression>node).expression || (<TaggedTemplateExpression>node).tag, diagnosticChainHead);
                 }
             }
             else {
@@ -5759,15 +5759,15 @@ module ts {
         }
 
         function resolveCallExpression(node: CallExpression, candidatesOutArray: Signature[]): Signature {
-            if (node.func.kind === SyntaxKind.SuperKeyword) {
-                var superType = checkSuperExpression(node.func);
+            if (node.expression.kind === SyntaxKind.SuperKeyword) {
+                var superType = checkSuperExpression(node.expression);
                 if (superType !== unknownType) {
                     return resolveCall(node, getSignaturesOfType(superType, SignatureKind.Construct), candidatesOutArray);
                 }
                 return resolveUntypedCall(node);
             }
 
-            var funcType = checkExpression(node.func);
+            var funcType = checkExpression(node.expression);
             var apparentType = getApparentType(funcType);
 
             if (apparentType === unknownType) {
@@ -5811,7 +5811,7 @@ module ts {
         }
 
         function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
-            var expressionType = checkExpression(node.func);
+            var expressionType = checkExpression(node.expression);
             // TS 1.0 spec: 4.11
             // If ConstructExpr is of type Any, Args can be any argument
             // list and the result of the operation is of type Any.
@@ -5911,7 +5911,7 @@ module ts {
 
         function checkCallExpression(node: CallExpression): Type {
             var signature = getResolvedSignature(node);
-            if (node.func.kind === SyntaxKind.SuperKeyword) {
+            if (node.expression.kind === SyntaxKind.SuperKeyword) {
                 return voidType;
             }
             if (node.kind === SyntaxKind.NewExpression) {
@@ -5936,7 +5936,7 @@ module ts {
         }
 
         function checkTypeAssertion(node: TypeAssertion): Type {
-            var exprType = checkExpression(node.operand);
+            var exprType = checkExpression(node.expression);
             var targetType = getTypeFromTypeNode(node.type);
             if (fullTypeCheck && targetType !== unknownType) {
                 var widenedType = getWidenedType(exprType, /*supressNoImplicitAnyErrors*/ true);
@@ -6171,7 +6171,7 @@ module ts {
                         // A property access expression is always classified as a reference.
                         // NOTE (not in spec): assignment to enum members should not be allowed
                         return !symbol || symbol === unknownSymbol || (symbol.flags & ~SymbolFlags.EnumMember) !== 0;
-                    case SyntaxKind.IndexedAccess:
+                    case SyntaxKind.ElementAccessExpression:
                         //  old compiler doesn't check indexed assess
                         return true;
                     case SyntaxKind.ParenExpression:
@@ -6187,9 +6187,9 @@ module ts {
                     case SyntaxKind.PropertyAccess:
                         var symbol = findSymbol(n);
                         return symbol && (symbol.flags & SymbolFlags.Variable) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & NodeFlags.Const) !== 0;
-                    case SyntaxKind.IndexedAccess:
-                        var index = (<IndexedAccess>n).index;
-                        var symbol = findSymbol((<IndexedAccess>n).object);
+                    case SyntaxKind.ElementAccessExpression:
+                        var index = (<ElementAccessExpression>n).argumentExpression;
+                        var symbol = findSymbol((<ElementAccessExpression>n).expression);
                         if (symbol && index.kind === SyntaxKind.StringLiteral) {
                             var name = (<LiteralExpression>index).text;
                             var prop = getPropertyOfType(getTypeOfSymbol(symbol), name);
@@ -6525,7 +6525,7 @@ module ts {
                 // - target in rhs of import statement
                 var ok =
                     (node.parent.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.parent).left === node) ||
-                    (node.parent.kind === SyntaxKind.IndexedAccess && (<IndexedAccess>node.parent).object === node) ||
+                    (node.parent.kind === SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).expression === node) ||
                     ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(<EntityName>node));
 
                 if (!ok) {
@@ -6565,8 +6565,8 @@ module ts {
                     return checkObjectLiteral(<ObjectLiteral>node, contextualMapper);
                 case SyntaxKind.PropertyAccess:
                     return checkPropertyAccess(<PropertyAccess>node);
-                case SyntaxKind.IndexedAccess:
-                    return checkIndexedAccess(<IndexedAccess>node);
+                case SyntaxKind.ElementAccessExpression:
+                    return checkIndexedAccess(<ElementAccessExpression>node);
                 case SyntaxKind.CallExpression:
                 case SyntaxKind.NewExpression:
                     return checkCallExpression(<CallExpression>node);
@@ -6763,7 +6763,7 @@ module ts {
             }
 
             function isSuperCallExpression(n: Node): boolean {
-                return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).func.kind === SyntaxKind.SuperKeyword;
+                return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).expression.kind === SyntaxKind.SuperKeyword;
             }
 
             function containsSuperCall(n: Node): boolean {
@@ -8139,7 +8139,7 @@ module ts {
                         case SyntaxKind.ParenExpression:
                             return enumIsConst ? evalConstant((<ParenExpression>e).expression) : undefined;
                         case SyntaxKind.Identifier:
-                        case SyntaxKind.IndexedAccess:
+                        case SyntaxKind.ElementAccessExpression:
                         case SyntaxKind.PropertyAccess:
                             if (!enumIsConst) {
                                 return undefined;
@@ -8157,12 +8157,12 @@ module ts {
                                 propertyName = (<Identifier>e).text;
                             }
                             else {
-                                if (e.kind === SyntaxKind.IndexedAccess) {
-                                    if ((<IndexedAccess>e).index.kind !== SyntaxKind.StringLiteral) {
+                                if (e.kind === SyntaxKind.ElementAccessExpression) {
+                                    if ((<ElementAccessExpression>e).argumentExpression.kind !== SyntaxKind.StringLiteral) {
                                         return undefined;
                                     }
-                                    var enumType = getTypeOfNode((<IndexedAccess>e).object);
-                                    propertyName = (<LiteralExpression>(<IndexedAccess>e).index).text;
+                                    var enumType = getTypeOfNode((<ElementAccessExpression>e).expression);
+                                    propertyName = (<LiteralExpression>(<ElementAccessExpression>e).argumentExpression).text;
                                 }
                                 else {
                                     var enumType = getTypeOfNode((<PropertyAccess>e).left);
@@ -8491,7 +8491,7 @@ module ts {
                 case SyntaxKind.ObjectLiteral:
                 case SyntaxKind.PropertyAssignment:
                 case SyntaxKind.PropertyAccess:
-                case SyntaxKind.IndexedAccess:
+                case SyntaxKind.ElementAccessExpression:
                 case SyntaxKind.CallExpression:
                 case SyntaxKind.NewExpression:
                 case SyntaxKind.TaggedTemplateExpression:
@@ -8907,8 +8907,8 @@ module ts {
                 // Intentional fall-through
                 case SyntaxKind.NumericLiteral:
                     // index access
-                    if (node.parent.kind == SyntaxKind.IndexedAccess && (<IndexedAccess>node.parent).index === node) {
-                        var objectType = checkExpression((<IndexedAccess>node.parent).object);
+                    if (node.parent.kind == SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).argumentExpression === node) {
+                        var objectType = checkExpression((<ElementAccessExpression>node.parent).expression);
                         if (objectType === unknownType) return undefined;
                         var apparentType = getApparentType(objectType);
                         if (apparentType === unknownType) return undefined;
@@ -9160,7 +9160,7 @@ module ts {
             return getNodeLinks(node).enumMemberValue;
         }
 
-        function getConstantValue(node: PropertyAccess | IndexedAccess): number {
+        function getConstantValue(node: PropertyAccess | ElementAccessExpression): number {
             var symbol = getNodeLinks(node).resolvedSymbol;
             if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
                 var declaration = symbol.valueDeclaration;
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index a3315bf35c5..810e9130062 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -2027,7 +2027,7 @@ module ts {
                     switch (parent.kind) {
                         case SyntaxKind.CallExpression:
                         case SyntaxKind.NewExpression:
-                            return (<CallExpression>parent).func === template;
+                            return (<CallExpression>parent).expression === template;
                         case SyntaxKind.ParenExpression:
                             return false;
                         case SyntaxKind.TaggedTemplateExpression:
@@ -2249,10 +2249,10 @@ module ts {
                 }
             }
 
-            function tryEmitConstantValue(node: PropertyAccess | IndexedAccess): boolean {
+            function tryEmitConstantValue(node: PropertyAccess | ElementAccessExpression): boolean {
                 var constantValue = resolver.getConstantValue(node);
                 if (constantValue !== undefined) {
-                    var propertyName = node.kind === SyntaxKind.PropertyAccess ? declarationNameToString((<PropertyAccess>node).right) : getTextOfNode((<IndexedAccess>node).index);
+                    var propertyName = node.kind === SyntaxKind.PropertyAccess ? declarationNameToString((<PropertyAccess>node).right) : getTextOfNode((<ElementAccessExpression>node).argumentExpression);
                     write(constantValue.toString() + " /* " + propertyName + " */");
                     return true;
                 }
@@ -2268,29 +2268,29 @@ module ts {
                 emit(node.right);
             }
 
-            function emitIndexedAccess(node: IndexedAccess) {
+            function emitIndexedAccess(node: ElementAccessExpression) {
                 if (tryEmitConstantValue(node)) {
                     return;
                 }
-                emit(node.object);
+                emit(node.expression);
                 write("[");
-                emit(node.index);
+                emit(node.argumentExpression);
                 write("]");
             }
 
             function emitCallExpression(node: CallExpression) {
                 var superCall = false;
-                if (node.func.kind === SyntaxKind.SuperKeyword) {
+                if (node.expression.kind === SyntaxKind.SuperKeyword) {
                     write("_super");
                     superCall = true;
                 }
                 else {
-                    emit(node.func);
-                    superCall = node.func.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.func).left.kind === SyntaxKind.SuperKeyword;
+                    emit(node.expression);
+                    superCall = node.expression.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.expression).left.kind === SyntaxKind.SuperKeyword;
                 }
                 if (superCall) {
                     write(".call(");
-                    emitThis(node.func);
+                    emitThis(node.expression);
                     if (node.arguments.length) {
                         write(", ");
                         emitCommaList(node.arguments, /*includeTrailingComma*/ false);
@@ -2306,7 +2306,7 @@ module ts {
 
             function emitNewExpression(node: NewExpression) {
                 write("new ");
-                emit(node.func);
+                emit(node.expression);
                 if (node.arguments) {
                     write("(");
                     emitCommaList(node.arguments, /*includeTrailingComma*/ false);
@@ -2323,12 +2323,12 @@ module ts {
 
             function emitParenExpression(node: ParenExpression) {
                 if (node.expression.kind === SyntaxKind.TypeAssertion) {
-                    var operand = (<TypeAssertion>node.expression).operand;
+                    var operand = (<TypeAssertion>node.expression).expression;
 
                     // Make sure we consider all nested cast expressions, e.g.:
                     // (<any><number><any>-A).x; 
                     while (operand.kind == SyntaxKind.TypeAssertion) {
-                        operand = (<TypeAssertion>operand).operand;
+                        operand = (<TypeAssertion>operand).expression;
                     }
 
                     // We have an expression of the form: (<Type>SubExpr)
@@ -2883,7 +2883,7 @@ module ts {
                     if (statement && statement.kind === SyntaxKind.ExpressionStatement) {
                         var expr = (<ExpressionStatement>statement).expression;
                         if (expr && expr.kind === SyntaxKind.CallExpression) {
-                            var func = (<CallExpression>expr).func;
+                            var func = (<CallExpression>expr).expression;
                             if (func && func.kind === SyntaxKind.SuperKeyword) {
                                 return <ExpressionStatement>statement;
                             }
@@ -3507,8 +3507,8 @@ module ts {
                         return emitComputedPropertyName(<ComputedPropertyName>node);
                     case SyntaxKind.PropertyAccess:
                         return emitPropertyAccess(<PropertyAccess>node);
-                    case SyntaxKind.IndexedAccess:
-                        return emitIndexedAccess(<IndexedAccess>node);
+                    case SyntaxKind.ElementAccessExpression:
+                        return emitIndexedAccess(<ElementAccessExpression>node);
                     case SyntaxKind.CallExpression:
                         return emitCallExpression(<CallExpression>node);
                     case SyntaxKind.NewExpression:
@@ -3516,7 +3516,7 @@ module ts {
                     case SyntaxKind.TaggedTemplateExpression:
                         return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
                     case SyntaxKind.TypeAssertion:
-                        return emit((<TypeAssertion>node).operand);
+                        return emit((<TypeAssertion>node).expression);
                     case SyntaxKind.ParenExpression:
                         return emitParenExpression(<ParenExpression>node);
                     case SyntaxKind.FunctionDeclaration:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 6d0e65223c1..6b173386382 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -262,12 +262,12 @@ module ts {
             case SyntaxKind.PropertyAccess:
                 return child((<PropertyAccess>node).left) ||
                     child((<PropertyAccess>node).right);
-            case SyntaxKind.IndexedAccess:
-                return child((<IndexedAccess>node).object) ||
-                    child((<IndexedAccess>node).index);
+            case SyntaxKind.ElementAccessExpression:
+                return child((<ElementAccessExpression>node).expression) ||
+                    child((<ElementAccessExpression>node).argumentExpression);
             case SyntaxKind.CallExpression:
             case SyntaxKind.NewExpression:
-                return child((<CallExpression>node).func) ||
+                return child((<CallExpression>node).expression) ||
                     children((<CallExpression>node).typeArguments) ||
                     children((<CallExpression>node).arguments);
             case SyntaxKind.TaggedTemplateExpression:
@@ -275,7 +275,7 @@ module ts {
                     child((<TaggedTemplateExpression>node).template);
             case SyntaxKind.TypeAssertion:
                 return child((<TypeAssertion>node).type) ||
-                    child((<TypeAssertion>node).operand);
+                    child((<TypeAssertion>node).expression);
             case SyntaxKind.ParenExpression:
                 return child((<ParenExpression>node).expression);
             case SyntaxKind.DeleteExpression:
@@ -502,7 +502,7 @@ module ts {
         }
         
         // Will either be a CallExpression or NewExpression.
-        return (<CallExpression>node).func;
+        return (<CallExpression>node).expression;
     }
 
     export function isExpression(node: Node): boolean {
@@ -516,7 +516,7 @@ module ts {
             case SyntaxKind.ArrayLiteral:
             case SyntaxKind.ObjectLiteral:
             case SyntaxKind.PropertyAccess:
-            case SyntaxKind.IndexedAccess:
+            case SyntaxKind.ElementAccessExpression:
             case SyntaxKind.CallExpression:
             case SyntaxKind.NewExpression:
             case SyntaxKind.TaggedTemplateExpression:
@@ -572,7 +572,7 @@ module ts {
                         return (<ForInStatement>parent).variable === node ||
                             (<ForInStatement>parent).expression === node;
                     case SyntaxKind.TypeAssertion:
-                        return node === (<TypeAssertion>parent).operand;
+                        return node === (<TypeAssertion>parent).expression;
                     case SyntaxKind.TemplateSpan:
                         return node === (<TemplateSpan>parent).expression;
                     default:
@@ -2798,7 +2798,7 @@ module ts {
             parseExpected(SyntaxKind.LessThanToken);
             node.type = parseType();
             parseExpected(SyntaxKind.GreaterThanToken);
-            node.operand = parseUnaryExpressionOrHigher();
+            node.expression = parseUnaryExpressionOrHigher();
             return finishNode(node);
         }
 
@@ -2853,21 +2853,21 @@ module ts {
                 }
 
                 if (token === SyntaxKind.OpenBracketToken) {
-                    var indexedAccess = <IndexedAccess>createNode(SyntaxKind.IndexedAccess, expression.pos);
-                    indexedAccess.object = expression;
+                    var indexedAccess = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression, expression.pos);
+                    indexedAccess.expression = expression;
                     indexedAccess.openBracketToken = parseTokenNode(SyntaxKind.OpenBracketToken);
 
                     // It's not uncommon for a user to write: "new Type[]".
                     // Check for that common pattern and report a better error message.
                     if (token !== SyntaxKind.CloseBracketToken) {
-                        indexedAccess.index = allowInAnd(parseExpression);
-                        if (indexedAccess.index.kind === SyntaxKind.StringLiteral || indexedAccess.index.kind === SyntaxKind.NumericLiteral) {
-                            var literal = <LiteralExpression>indexedAccess.index;
+                        indexedAccess.argumentExpression = allowInAnd(parseExpression);
+                        if (indexedAccess.argumentExpression.kind === SyntaxKind.StringLiteral || indexedAccess.argumentExpression.kind === SyntaxKind.NumericLiteral) {
+                            var literal = <LiteralExpression>indexedAccess.argumentExpression;
                             literal.text = internIdentifier(literal.text);
                         }
                     }
                     else {
-                        indexedAccess.index = createMissingNode();
+                        indexedAccess.argumentExpression = createMissingNode();
                     }
 
                     indexedAccess.closeBracketToken = parseTokenNode(SyntaxKind.CloseBracketToken);
@@ -2901,7 +2901,7 @@ module ts {
                     }
 
                     var callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
-                    callExpr.func = expression;
+                    callExpr.expression = expression;
                     callExpr.typeArguments = typeArguments;
                     callExpr.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
                     parseExpected(SyntaxKind.CloseParenToken);
@@ -2911,7 +2911,7 @@ module ts {
 
                 if (token === SyntaxKind.OpenParenToken) {
                     var callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
-                    callExpr.func = expression;
+                    callExpr.expression = expression;
                     parseExpected(SyntaxKind.OpenParenToken);
                     callExpr.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
                     parseExpected(SyntaxKind.CloseParenToken);
@@ -3123,7 +3123,7 @@ module ts {
         function parseNewExpression(): NewExpression {
             var node = <NewExpression>createNode(SyntaxKind.NewExpression);
             parseExpected(SyntaxKind.NewKeyword);
-            node.func = parseMemberExpressionOrHigher();
+            node.expression = parseMemberExpressionOrHigher();
             if (parseOptional(SyntaxKind.OpenParenToken) || (token === SyntaxKind.LessThanToken && (node.typeArguments = tryParse(parseTypeArgumentsAndOpenParen)))) {
                 node.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
                 parseExpected(SyntaxKind.CloseParenToken);
@@ -4120,7 +4120,7 @@ module ts {
         if (expr) {
             switch (expr.kind) {
                 case SyntaxKind.PropertyAccess:
-                case SyntaxKind.IndexedAccess:
+                case SyntaxKind.ElementAccessExpression:
                 case SyntaxKind.NewExpression:
                 case SyntaxKind.CallExpression:
                 case SyntaxKind.TaggedTemplateExpression:
@@ -4236,7 +4236,7 @@ module ts {
                 case SyntaxKind.FunctionDeclaration:            return checkFunctionDeclaration(<FunctionLikeDeclaration>node);
                 case SyntaxKind.FunctionExpression:             return checkFunctionExpression(<FunctionExpression>node);
                 case SyntaxKind.GetAccessor:                    return checkGetAccessor(<MethodDeclaration>node);
-                case SyntaxKind.IndexedAccess:                  return checkIndexedAccess(<IndexedAccess>node);
+                case SyntaxKind.ElementAccessExpression:                  return checkIndexedAccess(<ElementAccessExpression>node);
                 case SyntaxKind.IndexSignature:                 return checkIndexSignature(<SignatureDeclaration>node);
                 case SyntaxKind.InterfaceDeclaration:           return checkInterfaceDeclaration(<InterfaceDeclaration>node);
                 case SyntaxKind.LabeledStatement:               return checkLabeledStatement(<LabeledStatement>node);
@@ -4632,10 +4632,10 @@ module ts {
                 checkAccessor(node);
         }
 
-        function checkIndexedAccess(node: IndexedAccess) {
-            if (node.index.kind === SyntaxKind.Missing) {
+        function checkIndexedAccess(node: ElementAccessExpression) {
+            if (node.argumentExpression.kind === SyntaxKind.Missing) {
                 if (node.parent.kind === SyntaxKind.NewExpression &&
-                    (<NewExpression>node.parent).func === node) {
+                    (<NewExpression>node.parent).expression === node) {
 
                     var start = skipTrivia(sourceText, node.openBracketToken.pos);
                     var end = node.closeBracketToken.end;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 4a6a26856ff..a1180617867 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -170,7 +170,7 @@ module ts {
         PropertyAssignment,
         ShorthandPropertyAssignment,
         PropertyAccess,
-        IndexedAccess,
+        ElementAccessExpression,
         CallExpression,
         NewExpression,
         TaggedTemplateExpression,
@@ -512,15 +512,15 @@ module ts {
         right: Identifier;
     }
 
-    export interface IndexedAccess extends Expression {
-        object: Expression;
+    export interface ElementAccessExpression extends Expression {
+        expression: Expression;
         openBracketToken: Node;
-        index: Expression;
+        argumentExpression: Expression;
         closeBracketToken: Node;
     }
 
     export interface CallExpression extends Expression {
-        func: Expression;
+        expression: Expression;
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
@@ -536,7 +536,7 @@ module ts {
 
     export interface TypeAssertion extends Expression {
         type: TypeNode;
-        operand: Expression;
+        expression: Expression;
     }
 
     export interface Statement extends Node { }
@@ -890,7 +890,7 @@ module ts {
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
-        getConstantValue(node: PropertyAccess | IndexedAccess): number;
+        getConstantValue(node: PropertyAccess | ElementAccessExpression): number;
         isEmitBlocked(sourceFile?: SourceFile): boolean;
     }
 
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index 8122c639680..5d5ecaa661f 100644
--- a/src/harness/typeWriter.ts
+++ b/src/harness/typeWriter.ts
@@ -32,7 +32,7 @@ class TypeWriterWalker {
             case ts.SyntaxKind.ArrayLiteral:
             case ts.SyntaxKind.ObjectLiteral:
             case ts.SyntaxKind.PropertyAccess:
-            case ts.SyntaxKind.IndexedAccess:
+            case ts.SyntaxKind.ElementAccessExpression:
             case ts.SyntaxKind.CallExpression:
             case ts.SyntaxKind.NewExpression:
             case ts.SyntaxKind.TypeAssertion:
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
index 7867751a96f..fe7c3af5597 100644
--- a/src/services/breakpoints.ts
+++ b/src/services/breakpoints.ts
@@ -243,7 +243,7 @@ module ts.BreakpointResolver {
 
                         // Breakpoint in type assertion goes to its operand
                         if (node.parent.kind === SyntaxKind.TypeAssertion && (<TypeAssertion>node.parent).type === node) {
-                            return spanInNode((<TypeAssertion>node.parent).operand);
+                            return spanInNode((<TypeAssertion>node.parent).expression);
                         }
 
                         // return type of function go to previous token
@@ -484,7 +484,7 @@ module ts.BreakpointResolver {
 
             function spanInGreaterThanOrLessThanToken(node: Node): TextSpan {
                 if (node.parent.kind === SyntaxKind.TypeAssertion) {
-                    return spanInNode((<TypeAssertion>node.parent).operand);
+                    return spanInNode((<TypeAssertion>node.parent).expression);
                 }
 
                 return spanInNode(node.parent);
diff --git a/src/services/services.ts b/src/services/services.ts
index 167bf00c820..4e7da91bbf5 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1934,14 +1934,14 @@ module ts {
         if (isRightSideOfPropertyAccess(node)) {
             node = node.parent;
         }
-        return node && node.parent && node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).func === node;
+        return node && node.parent && node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
     }
 
     function isNewExpressionTarget(node: Node): boolean {
         if (isRightSideOfPropertyAccess(node)) {
             node = node.parent;
         }
-        return node && node.parent && node.parent.kind === SyntaxKind.NewExpression && (<CallExpression>node.parent).func === node;
+        return node && node.parent && node.parent.kind === SyntaxKind.NewExpression && (<CallExpression>node.parent).expression === node;
     }
 
     function isNameOfModuleDeclaration(node: Node) {
@@ -1970,8 +1970,8 @@ module ts {
                 case SyntaxKind.SetAccessor:
                 case SyntaxKind.ModuleDeclaration:
                     return (<Declaration>node.parent).name === node;
-                case SyntaxKind.IndexedAccess:
-                    return (<IndexedAccess>node.parent).index === node;
+                case SyntaxKind.ElementAccessExpression:
+                    return (<ElementAccessExpression>node.parent).argumentExpression === node;
             }
         }
 
@@ -2903,7 +2903,7 @@ module ts {
                             signature = candidateSignatures[0];
                         }
 
-                        var useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.func.kind === SyntaxKind.SuperKeyword;
+                        var useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.expression.kind === SyntaxKind.SuperKeyword;
                         var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
 
                         if (!contains(allSignatures, signature.target || signature)) {