Merge pull request #11114 from Microsoft/restructureASTToParseReactAttributesAsObjectLiteral

yuit · web-flow · commit 3d921175a961 · 2016-09-26T15:04:38.000-07:00
Restructure ast to parse react attributes as object literal
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -5948,7 +5948,7 @@ namespace ts {
 
         // Returns true if the given expression contains (at any level of nesting) a function or arrow expression
         // that is subject to contextual typing.
-        function isContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElement): boolean {
+        function isContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElementLike): boolean {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
             switch (node.kind) {
                 case SyntaxKind.FunctionExpression:
@@ -9793,7 +9793,7 @@ namespace ts {
             return getContextualTypeForObjectLiteralElement(node);
         }
 
-        function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElement) {
+        function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElementLike) {
             const objectLiteral = <ObjectLiteralExpression>element.parent;
             const type = getApparentTypeOfContextualType(objectLiteral);
             if (type) {
@@ -9910,7 +9910,7 @@ namespace ts {
                     return getContextualTypeForBinaryOperand(node);
                 case SyntaxKind.PropertyAssignment:
                 case SyntaxKind.ShorthandPropertyAssignment:
-                    return getContextualTypeForObjectLiteralElement(<ObjectLiteralElement>parent);
+                    return getContextualTypeForObjectLiteralElement(<ObjectLiteralElementLike>parent);
                 case SyntaxKind.ArrayLiteralExpression:
                     return getContextualTypeForElementExpression(node);
                 case SyntaxKind.ConditionalExpression:
@@ -13186,7 +13186,7 @@ namespace ts {
             return sourceType;
         }
 
-        function checkObjectLiteralDestructuringPropertyAssignment(objectLiteralType: Type, property: ObjectLiteralElement, contextualMapper?: TypeMapper) {
+        function checkObjectLiteralDestructuringPropertyAssignment(objectLiteralType: Type, property: ObjectLiteralElementLike, contextualMapper?: TypeMapper) {
             if (property.kind === SyntaxKind.PropertyAssignment || property.kind === SyntaxKind.ShorthandPropertyAssignment) {
                 const name = <PropertyName>(<PropertyAssignment>property).name;
                 if (name.kind === SyntaxKind.ComputedPropertyName) {
@@ -18446,7 +18446,7 @@ namespace ts {
             //     for ({ skills: { primary, secondary } } = multiRobot, i = 0; i < 1; i++) {
             if (expr.parent.kind === SyntaxKind.PropertyAssignment) {
                 const typeOfParentObjectLiteral = getTypeOfArrayLiteralOrObjectLiteralDestructuringAssignment(<Expression>expr.parent.parent);
-                return checkObjectLiteralDestructuringPropertyAssignment(typeOfParentObjectLiteral || unknownType, <ObjectLiteralElement>expr.parent);
+                return checkObjectLiteralDestructuringPropertyAssignment(typeOfParentObjectLiteral || unknownType, <ObjectLiteralElementLike>expr.parent);
             }
             // Array literal assignment - array destructuring pattern
             Debug.assert(expr.parent.kind === SyntaxKind.ArrayLiteralExpression);
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -416,7 +416,7 @@ namespace ts {
         return node;
     }
 
-    export function createObjectLiteral(properties?: ObjectLiteralElement[], location?: TextRange, multiLine?: boolean) {
+    export function createObjectLiteral(properties?: ObjectLiteralElementLike[], location?: TextRange, multiLine?: boolean) {
         const node = <ObjectLiteralExpression>createNode(SyntaxKind.ObjectLiteralExpression, location);
         node.properties = createNodeArray(properties);
         if (multiLine) {
@@ -425,7 +425,7 @@ namespace ts {
         return node;
     }
 
-    export function updateObjectLiteral(node: ObjectLiteralExpression, properties: ObjectLiteralElement[]) {
+    export function updateObjectLiteral(node: ObjectLiteralExpression, properties: ObjectLiteralElementLike[]) {
         if (node.properties !== properties) {
             return updateNode(createObjectLiteral(properties, node, node.multiLine), node);
         }
@@ -2069,7 +2069,7 @@ namespace ts {
         }
     }
 
-    export function createExpressionForObjectLiteralElement(node: ObjectLiteralExpression, property: ObjectLiteralElement, receiver: Expression): Expression {
+    export function createExpressionForObjectLiteralElementLike(node: ObjectLiteralExpression, property: ObjectLiteralElementLike, receiver: Expression): Expression {
         switch (property.kind) {
             case SyntaxKind.GetAccessor:
             case SyntaxKind.SetAccessor:
@@ -2086,7 +2086,7 @@ namespace ts {
     function createExpressionForAccessorDeclaration(properties: NodeArray<Declaration>, property: AccessorDeclaration, receiver: Expression, multiLine: boolean) {
         const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property);
         if (property === firstAccessor) {
-            const properties: ObjectLiteralElement[] = [];
+            const properties: ObjectLiteralElementLike[] = [];
             if (getAccessor) {
                 const getterFunction = createFunctionExpression(
                     /*asteriskToken*/ undefined,
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -4121,7 +4121,7 @@ namespace ts {
             return undefined;
         }
 
-        function parseObjectLiteralElement(): ObjectLiteralElement {
+        function parseObjectLiteralElement(): ObjectLiteralElementLike {
             const fullStart = scanner.getStartPos();
             const decorators = parseDecorators();
             const modifiers = parseModifiers();
diff --git a/src/compiler/transformers/es6.ts b/src/compiler/transformers/es6.ts
@@ -1281,7 +1281,7 @@ namespace ts {
             setNodeEmitFlags(propertyName, NodeEmitFlags.NoComments | NodeEmitFlags.NoLeadingSourceMap);
             setSourceMapRange(propertyName, firstAccessor.name);
 
-            const properties: ObjectLiteralElement[] = [];
+            const properties: ObjectLiteralElementLike[] = [];
             if (getAccessor) {
                 const getterFunction = transformFunctionLikeToExpression(getAccessor, /*location*/ undefined, /*name*/ undefined);
                 setSourceMapRange(getterFunction, getSourceMapRange(getAccessor));
@@ -1965,7 +1965,7 @@ namespace ts {
                 temp,
                 setNodeEmitFlags(
                     createObjectLiteral(
-                        visitNodes(properties, visitor, isObjectLiteralElement, 0, numInitialProperties),
+                        visitNodes(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
                         /*location*/ undefined,
                         node.multiLine
                     ),
@@ -2499,7 +2499,7 @@ namespace ts {
          *
          * @param node A MethodDeclaration node.
          */
-        function visitMethodDeclaration(node: MethodDeclaration): ObjectLiteralElement {
+        function visitMethodDeclaration(node: MethodDeclaration): ObjectLiteralElementLike {
             // We should only get here for methods on an object literal with regular identifier names.
             // Methods on classes are handled in visitClassDeclaration/visitClassExpression.
             // Methods with computed property names are handled in visitObjectLiteralExpression.
@@ -2518,7 +2518,7 @@ namespace ts {
          *
          * @param node A ShorthandPropertyAssignment node.
          */
-        function visitShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElement {
+        function visitShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElementLike {
             return createPropertyAssignment(
                 node.name,
                 getSynthesizedClone(node.name),
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
@@ -1025,7 +1025,7 @@ namespace ts {
             const temp = declareLocal();
             emitAssignment(temp,
                 createObjectLiteral(
-                    visitNodes(properties, visitor, isObjectLiteralElement, 0, numInitialProperties),
+                    visitNodes(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
                     /*location*/ undefined,
                     multiLine
                 )
@@ -1035,13 +1035,13 @@ namespace ts {
             expressions.push(multiLine ? startOnNewLine(getMutableClone(temp)) : temp);
             return inlineExpressions(expressions);
 
-            function reduceProperty(expressions: Expression[], property: ObjectLiteralElement) {
+            function reduceProperty(expressions: Expression[], property: ObjectLiteralElementLike) {
                 if (containsYield(property) && expressions.length > 0) {
                     emitStatement(createStatement(inlineExpressions(expressions)));
                     expressions = [];
                 }
 
-                const expression = createExpressionForObjectLiteralElement(node, property, temp);
+                const expression = createExpressionForObjectLiteralElementLike(node, property, temp);
                 const visited = visitNode(expression, visitor, isExpression);
                 if (visited) {
                     if (multiLine) {
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
@@ -850,7 +850,7 @@ namespace ts {
             return node;
         }
 
-        function substituteShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElement {
+        function substituteShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElementLike {
             const name = node.name;
             const exportedOrImportedName = substituteExpressionIdentifier(name);
             if (exportedOrImportedName !== name) {
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
@@ -288,7 +288,7 @@ namespace ts {
                 }
             }
 
-            const exportedNames: ObjectLiteralElement[] = [];
+            const exportedNames: ObjectLiteralElementLike[] = [];
             if (exportedLocalNames) {
                 for (const exportedLocalName of exportedLocalNames) {
                     // write name of exported declaration, i.e 'export var x...'
@@ -1107,7 +1107,7 @@ namespace ts {
             return false;
         }
 
-        function hasExportedReferenceInObjectDestructuringElement(node: ObjectLiteralElement): boolean {
+        function hasExportedReferenceInObjectDestructuringElement(node: ObjectLiteralElementLike): boolean {
             if (isShorthandPropertyAssignment(node)) {
                 return isExportedBinding(node.name);
             }
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
@@ -1560,7 +1560,7 @@ namespace ts {
 
         function addNewTypeMetadata(node: Declaration, decoratorExpressions: Expression[]) {
             if (compilerOptions.emitDecoratorMetadata) {
-                let properties: ObjectLiteralElement[];
+                let properties: ObjectLiteralElementLike[];
                 if (shouldAddTypeMetadata(node)) {
                     (properties || (properties = [])).push(createPropertyAssignment("type", createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, /*equalsGreaterThanToken*/ undefined, serializeTypeOfNode(node))));
                 }
@@ -3273,7 +3273,7 @@ namespace ts {
             return node;
         }
 
-        function substituteShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElement {
+        function substituteShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElementLike {
             if (enabledSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports) {
                 const name = node.name;
                 const exportedName = trySubstituteNamespaceExportedName(name);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -648,6 +648,8 @@ namespace ts {
         name?: PropertyName;
    }
 
+    export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration | AccessorDeclaration;
+
     // @kind(SyntaxKind.PropertyAssignment)
     export interface PropertyAssignment extends ObjectLiteralElement {
         _propertyAssignmentBrand: any;
@@ -1048,10 +1050,19 @@ namespace ts {
         expression: Expression;
     }
 
+    /**
+      * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to
+      * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be
+      * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type
+      * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
+     **/
+    export interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
+        properties: NodeArray<T>;
+    }
+
     // An ObjectLiteralExpression is the declaration node for an anonymous symbol.
     // @kind(SyntaxKind.ObjectLiteralExpression)
-    export interface ObjectLiteralExpression extends PrimaryExpression, Declaration {
-        properties: NodeArray<ObjectLiteralElement>;
+    export interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike> {
         /* @internal */
         multiLine?: boolean;
     }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3736,7 +3736,7 @@ namespace ts {
             || kind === SyntaxKind.SemicolonClassElement;
     }
 
-    export function isObjectLiteralElement(node: Node): node is ObjectLiteralElement {
+    export function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike {
         const kind = node.kind;
         return kind === SyntaxKind.PropertyAssignment
             || kind === SyntaxKind.ShorthandPropertyAssignment
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
@@ -772,7 +772,7 @@ namespace ts {
 
             case SyntaxKind.ObjectLiteralExpression:
                 return updateObjectLiteral(<ObjectLiteralExpression>node,
-                    visitNodes((<ObjectLiteralExpression>node).properties, visitor, isObjectLiteralElement));
+                    visitNodes((<ObjectLiteralExpression>node).properties, visitor, isObjectLiteralElementLike));
 
             case SyntaxKind.PropertyAccessExpression:
                 return updatePropertyAccess(<PropertyAccessExpression>node,

Original file line number	Diff line number	Diff line change
`@@ -4121,7 +4121,7 @@ namespace ts {`
`4121`	`4121`	`return undefined;`
`4122`	`4122`	`}`
`4123`	`4123`
`4124`		`- function parseObjectLiteralElement(): ObjectLiteralElement {`
	`4124`	`+ function parseObjectLiteralElement(): ObjectLiteralElementLike {`
`4125`	`4125`	`const fullStart = scanner.getStartPos();`
`4126`	`4126`	`const decorators = parseDecorators();`
`4127`	`4127`	`const modifiers = parseModifiers();`
Original file line number	Diff line number	Diff line change
`@@ -850,7 +850,7 @@ namespace ts {`
`850`	`850`	`return node;`
`851`	`851`	`}`
`852`	`852`
`853`		`- function substituteShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElement {`
	`853`	`+ function substituteShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElementLike {`
`854`	`854`	`const name = node.name;`
`855`	`855`	`const exportedOrImportedName = substituteExpressionIdentifier(name);`
`856`	`856`	`if (exportedOrImportedName !== name) {`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ namespace ts {`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`
`291`		`- const exportedNames: ObjectLiteralElement[] = [];`
	`291`	`+ const exportedNames: ObjectLiteralElementLike[] = [];`
`292`	`292`	`if (exportedLocalNames) {`
`293`	`293`	`for (const exportedLocalName of exportedLocalNames) {`
`294`	`294`	`// write name of exported declaration, i.e 'export var x...'`
`@@ -1107,7 +1107,7 @@ namespace ts {`
`1107`	`1107`	`return false;`
`1108`	`1108`	`}`
`1109`	`1109`
`1110`		`- function hasExportedReferenceInObjectDestructuringElement(node: ObjectLiteralElement): boolean {`
	`1110`	`+ function hasExportedReferenceInObjectDestructuringElement(node: ObjectLiteralElementLike): boolean {`
`1111`	`1111`	`if (isShorthandPropertyAssignment(node)) {`
`1112`	`1112`	`return isExportedBinding(node.name);`
`1113`	`1113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3736,7 +3736,7 @@ namespace ts {`
`3736`	`3736`	`\|\| kind === SyntaxKind.SemicolonClassElement;`
`3737`	`3737`	`}`
`3738`	`3738`
`3739`		`- export function isObjectLiteralElement(node: Node): node is ObjectLiteralElement {`
	`3739`	`+ export function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike {`
`3740`	`3740`	`const kind = node.kind;`
`3741`	`3741`	`return kind === SyntaxKind.PropertyAssignment`
`3742`	`3742`	`\|\| kind === SyntaxKind.ShorthandPropertyAssignment`