Merge pull request #1127 from Microsoft/shorthandProperty

Shorthand property

Author: Yui

src/compiler/binder.ts

@@ -380,6 +380,7 @@ module ts {
                     break;
                 case SyntaxKind.Property:
                 case SyntaxKind.PropertyAssignment:
+                case SyntaxKind.ShorthandPropertyAssignment:
                     bindDeclaration(<Declaration>node, SymbolFlags.Property, SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
                     break;
                 case SyntaxKind.EnumMember:

src/compiler/checker.ts

@@ -93,6 +93,7 @@ module ts {
             getReturnTypeOfSignature: getReturnTypeOfSignature,
             getSymbolsInScope: getSymbolsInScope,
             getSymbolInfo: getSymbolInfo,
+            getShorthandAssignmentValueSymbol: getShorthandAssignmentValueSymbol,
             getTypeOfNode: getTypeOfNode,
             typeToString: typeToString,
             getSymbolDisplayBuilder: getSymbolDisplayBuilder,
@@ -109,6 +110,7 @@ module ts {
             getAliasedSymbol: resolveImport,
             isUndefinedSymbol: symbol => symbol === undefinedSymbol,
             isArgumentsSymbol: symbol => symbol === argumentsSymbol,
+            hasEarlyErrors: hasEarlyErrors,
             isEmitBlocked: isEmitBlocked
         };
 
@@ -1665,6 +1667,13 @@ module ts {
                 }
                 return type;
             }
+
+            // If it is a short-hand property assignment; Use the type of the identifier
+            if (declaration.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                var type = checkIdentifier(<Identifier>declaration.name);
+                return type
+            }
+
             // Rest parameters default to type any[], other parameters default to type any
             var type = declaration.flags & NodeFlags.Rest ? createArrayType(anyType) : anyType;
             checkImplicitAny(type);
@@ -2399,7 +2408,7 @@ module ts {
         }
 
         // Return the symbol for the property with the given name in the given type. Creates synthetic union properties when
-        // necessary, maps primtive types and type parameters are to their apparent types, and augments with properties from
+        // necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from
         // Object and Function as appropriate.
         function getPropertyOfType(type: Type, name: string): Symbol {
             if (type.flags & TypeFlags.Union) {
@@ -2434,7 +2443,7 @@ module ts {
         }
 
         // Return the signatures of the given kind in the given type. Creates synthetic union signatures when necessary and
-        // maps primtive types and type parameters are to their apparent types.
+        // maps primitive types and type parameters are to their apparent types.
         function getSignaturesOfType(type: Type, kind: SignatureKind): Signature[] {
             return getSignaturesOfObjectOrUnionType(getApparentType(type), kind);
         }
@@ -2447,7 +2456,7 @@ module ts {
         }
 
         // Return the index type of the given kind in the given type. Creates synthetic union index types when necessary and
-        // maps primtive types and type parameters are to their apparent types.
+        // maps primitive types and type parameters are to their apparent types.
         function getIndexTypeOfType(type: Type, kind: IndexKind): Type {
             return getIndexTypeOfObjectOrUnionType(getApparentType(type), kind);
         }
@@ -5000,7 +5009,15 @@ module ts {
                 if (hasProperty(members, id)) {
                     var member = members[id];
                     if (member.flags & SymbolFlags.Property) {
-                        var type = checkExpression((<PropertyDeclaration>member.declarations[0]).initializer, contextualMapper);
+                        var memberDecl = <PropertyDeclaration>member.declarations[0];
+                        var type: Type;
+                        if (memberDecl.kind === SyntaxKind.PropertyAssignment) {
+                            type = checkExpression(memberDecl.initializer, contextualMapper);
+                        }
+                        else {
+                            Debug.assert(memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment);
+                            type = checkExpression(memberDecl.name, contextualMapper);
+                        }
                         var prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
                         prop.declarations = member.declarations;
                         prop.parent = member.parent;
@@ -8816,6 +8833,16 @@ module ts {
             return undefined;
         }
 
+        function getShorthandAssignmentValueSymbol(location: Node): Symbol {
+            // The function returns a value symbol of an identifier in the short-hand property assignment.
+            // This is necessary as an identifier in short-hand property assignment can contains two meaning:
+            // property name and property value.
+            if (location && location.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                return resolveEntityName(location, (<ShortHandPropertyDeclaration>location).name, SymbolFlags.Value);
+            }
+            return undefined;
+        }
+
         function getTypeOfNode(node: Node): Type {
             if (isInsideWithStatementBody(node)) {
                 // We cannot answer semantic questions within a with block, do not proceed any further

src/compiler/diagnosticInformationMap.generated.ts

@@ -122,6 +122,7 @@ module ts {
         let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." },
         Invalid_template_literal_expected: { code: 1158, category: DiagnosticCategory.Error, key: "Invalid template literal; expected '}'" },
         Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1159, category: DiagnosticCategory.Error, key: "Tagged templates are only available when targeting ECMAScript 6 and higher." },
+        A_object_member_cannot_be_declared_optional: { code: 1160, category: DiagnosticCategory.Error, key: "A object member cannot be declared optional." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },

src/compiler/diagnosticMessages.json

@@ -480,6 +480,11 @@
         "code": 1159
     },
 
+    "A object member cannot be declared optional.": {
+        "category": "Error",
+        "code":  1160
+    },
+
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300

src/compiler/emitter.ts

@@ -927,13 +927,14 @@ module ts {
                 }
             }
 
-            function isNonExpressionIdentifier(node: Identifier) {
+            function isNotExpressionIdentifier(node: Identifier) {
                 var parent = node.parent;
                 switch (parent.kind) {
                     case SyntaxKind.Parameter:
                     case SyntaxKind.VariableDeclaration:
                     case SyntaxKind.Property:
                     case SyntaxKind.PropertyAssignment:
+                    case SyntaxKind.ShorthandPropertyAssignment:
                     case SyntaxKind.EnumMember:
                     case SyntaxKind.Method:
                     case SyntaxKind.FunctionDeclaration:
@@ -957,17 +958,24 @@ module ts {
                 }
             }
 
-            function emitIdentifier(node: Identifier) {
-                if (!isNonExpressionIdentifier(node)) {
-                    var prefix = resolver.getExpressionNamePrefix(node);
-                    if (prefix) {
-                        write(prefix);
-                        write(".");
-                    }
+            function emitExpressionIdentifier(node: Identifier) {
+                var prefix = resolver.getExpressionNamePrefix(node);
+                if (prefix) {
+                    write(prefix);
+                    write(".");
                 }
                 write(getSourceTextOfLocalNode(node));
             }
 
+            function emitIdentifier(node: Identifier) {
+                if (!isNotExpressionIdentifier(node)) {
+                    emitExpressionIdentifier(node);
+                }
+                else {
+                    write(getSourceTextOfLocalNode(node));
+                }
+            }
+
             function emitThis(node: Node) {
                 if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.LexicalThis) {
                     write("_this");
@@ -1033,6 +1041,36 @@ module ts {
                 emitTrailingComments(node);
             }
 
+            function emitShortHandPropertyAssignment(node: ShortHandPropertyDeclaration) {
+                function emitAsNormalPropertyAssignment() {
+                    emitLeadingComments(node);
+                    // Emit identifier as an identifier
+                    emit(node.name);
+                    write(": ");
+                    // Even though this is stored as identified because it is in short-hand property assignment,
+                    // treated it as expression 
+                    emitExpressionIdentifier(node.name);
+                    emitTrailingComments(node);
+                }
+
+                if (compilerOptions.target < ScriptTarget.ES6) {
+                    emitAsNormalPropertyAssignment();
+                }
+                else if (compilerOptions.target >= ScriptTarget.ES6) {
+                    // If short-hand property has a prefix, then regardless of the target version, we will emit it as normal property assignment
+                    var prefix = resolver.getExpressionNamePrefix(node.name);
+                    if (prefix) {
+                        emitAsNormalPropertyAssignment();
+                    }
+                    // If short-hand property has no prefix, emit it as short-hand.
+                    else {
+                        emitLeadingComments(node);
+                        emit(node.name);
+                        emitTrailingComments(node);
+                    }
+                }
+            }
+
             function tryEmitConstantValue(node: PropertyAccess | IndexedAccess): boolean {
                 var constantValue = resolver.getConstantValue(node);
                 if (constantValue !== undefined) {
@@ -2250,6 +2288,8 @@ module ts {
                         return emitObjectLiteral(<ObjectLiteral>node);
                     case SyntaxKind.PropertyAssignment:
                         return emitPropertyAssignment(<PropertyDeclaration>node);
+                    case SyntaxKind.ShorthandPropertyAssignment:
+                        return emitShortHandPropertyAssignment(<ShortHandPropertyDeclaration>node);
                     case SyntaxKind.PropertyAccess:
                         return emitPropertyAccess(<PropertyAccess>node);
                     case SyntaxKind.IndexedAccess:

src/compiler/parser.ts

@@ -202,6 +202,7 @@ module ts {
                     child((<ParameterDeclaration>node).initializer);
             case SyntaxKind.Property:
             case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
                 return child((<PropertyDeclaration>node).name) ||
                     child((<PropertyDeclaration>node).type) ||
                     child((<PropertyDeclaration>node).initializer);
@@ -580,6 +581,7 @@ module ts {
             case SyntaxKind.VariableDeclaration:
             case SyntaxKind.Property:
             case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
             case SyntaxKind.EnumMember:
             case SyntaxKind.Method:
             case SyntaxKind.FunctionDeclaration:
@@ -2729,22 +2731,41 @@ module ts {
             return finishNode(node);
         }
 
-        function parsePropertyAssignment(): PropertyDeclaration {
-            var node = <PropertyDeclaration>createNode(SyntaxKind.PropertyAssignment);
-            node.name = parsePropertyName();
+        function parsePropertyAssignment(): Declaration {
+            var nodePos = scanner.getStartPos();
+            var nameToken = token;
+            var propertyName = parsePropertyName();
+            var node: Declaration;
             if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
+                node = <PropertyDeclaration>createNode(SyntaxKind.PropertyAssignment, nodePos);
+                node.name = propertyName;
                 var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false);
                 var body = parseBody(/* ignoreMissingOpenBrace */ false);
                 // do not propagate property name as name for function expression
                 // for scenarios like 
                 // var x = 1;
                 // var y = { x() { } } 
                 // otherwise this will bring y.x into the scope of x which is incorrect
-                node.initializer = makeFunctionExpression(SyntaxKind.FunctionExpression, node.pos, undefined, sig, body);
+                (<PropertyDeclaration>node).initializer = makeFunctionExpression(SyntaxKind.FunctionExpression, node.pos, undefined, sig, body);
+                return finishNode(node);
+            }
+            // Disallow optional property assignment
+            if (token === SyntaxKind.QuestionToken) {
+                var questionStart = scanner.getTokenPos();
+                grammarErrorAtPos(questionStart, scanner.getStartPos() - questionStart, Diagnostics.A_object_member_cannot_be_declared_optional);
+                nextToken();
+            }
+
+            // Parse to check if it is short-hand property assignment or normal property assignment
+            if (token !== SyntaxKind.ColonToken && nameToken === SyntaxKind.Identifier) {
+                node = <ShortHandPropertyDeclaration>createNode(SyntaxKind.ShorthandPropertyAssignment, nodePos);
+                node.name = propertyName;
             }
             else {
+                node = <PropertyDeclaration>createNode(SyntaxKind.PropertyAssignment, nodePos);
+                node.name = propertyName;
                 parseExpected(SyntaxKind.ColonToken);
-                node.initializer = parseAssignmentExpression(false);
+                (<PropertyDeclaration>node).initializer = parseAssignmentExpression(false);
             }
             return finishNode(node);
         }
@@ -2794,6 +2815,9 @@ module ts {
                 if (p.kind === SyntaxKind.PropertyAssignment) {
                     currentKind = Property;
                 }
+                else if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                    currentKind = Property;
+                }
                 else if (p.kind === SyntaxKind.GetAccessor) {
                     currentKind = GetAccessor;
                 }

src/compiler/types.ts

@@ -167,6 +167,7 @@ module ts {
         ArrayLiteral,
         ObjectLiteral,
         PropertyAssignment,
+        ShorthandPropertyAssignment,
         PropertyAccess,
         IndexedAccess,
         CallExpression,
@@ -335,6 +336,10 @@ module ts {
         initializer?: Expression;
     }
 
+    export interface ShortHandPropertyDeclaration extends Declaration {
+        name: Identifier;
+    }
+
     export interface ParameterDeclaration extends VariableDeclaration { }
 
     /**
@@ -719,6 +724,7 @@ module ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
         getSymbolInfo(node: Node): Symbol;
+        getShorthandAssignmentValueSymbol(location: Node): Symbol;
         getTypeOfNode(node: Node): Type;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;