wip-address PR

microsoft · yuit · Jun 24, 2016 · Jun 23, 2016 · Jun 23, 2016 · Jun 23, 2016
commit 7a3f88a1936089c7d948258188a6f1274f709f10
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -9628,8 +9628,9 @@ namespace ts {
         /**
          * Returns true iff React would emit this tag name as a string rather than an identifier or qualified name
          */
-        function isJsxIntrinsicIdentifier(tagName: LeftHandSideExpression) {
-            if (tagName.kind === SyntaxKind.PropertyAccessExpression) {
+        function isJsxIntrinsicIdentifier(tagName: JsxTagNameExpression) {
+            // TODO (yuisu): comment
+            if (tagName.kind === SyntaxKind.PropertyAccessExpression || tagName.kind === SyntaxKind.ThisKeyword) {
                 return false;
             }
             else {
@@ -9830,7 +9831,7 @@ namespace ts {
                 return anyType;
             }
             else if (elemType.flags & TypeFlags.StringLiteral) {
-                // If the elemType is a stringLiteral type, we can then provide a check and give
+                // If the elemType is a stringLiteral type, we can then provide a check to make sure that the string literal type is one of the Jsx intrinsic element type
                 const intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements);
                 if (intrinsicElementsType !== unknownType) {
                     const stringLiteralTypeName = (<StringLiteralType>elemType).text;

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -3575,7 +3575,7 @@ namespace ts {
             return finishNode(node);
         }
 
-        function tagNamesAreEquivalent(lhs: LeftHandSideExpression, rhs: LeftHandSideExpression): boolean {
+        function tagNamesAreEquivalent(lhs: JsxTagNameExpression, rhs: JsxTagNameExpression): boolean {
             if (lhs.kind !== rhs.kind) {
                 return false;
             }
@@ -3588,8 +3588,9 @@ namespace ts {
                 return true;
             }
 
+            // If we are at this statement then we must have PropertyAccessExpression
             return (<PropertyAccessExpression>lhs).name.text === (<PropertyAccessExpression>rhs).name.text &&
-                tagNamesAreEquivalent((<PropertyAccessExpression>lhs).expression, (<PropertyAccessExpression>rhs).expression);
+                tagNamesAreEquivalent((<PropertyAccessExpression>lhs).expression as JsxTagNameExpression, (<PropertyAccessExpression>rhs).expression as JsxTagNameExpression);
         }
 
 
@@ -3720,12 +3721,14 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parseJsxElementName(): LeftHandSideExpression {
+        function parseJsxElementName(): JsxTagNameExpression {
             scanJsxIdentifier();
-            // JsxElement can have name in the form of property-access expression or an identifier or string literal
+            // JsxElement can have name in the form of
+            //      propertyAccessExpression
+            //      primaryExpression in the form of an identifier and "this" keyword
             // We can't just simply use parseLeftHandSideExpressionOrHigher because then we will start consider class,function etc as a keyword
             // We only want to consider "this" as a primaryExpression
-            let expression: LeftHandSideExpression = token === SyntaxKind.ThisKeyword ?
+            let expression: JsxTagNameExpression = token === SyntaxKind.ThisKeyword ?
                 parseTokenNode<PrimaryExpression>() : parseIdentifierName();
             while (parseOptional(SyntaxKind.DotToken)) {
                 const propertyAccess: PropertyAccessExpression = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos); 

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1042,11 +1042,13 @@ namespace ts {
         closingElement: JsxClosingElement;
     }
 
+    export type JsxTagNameExpression = PrimaryExpression | PropertyAccessExpression;
+
     /// The opening element of a <Tag>...</Tag> JsxElement
     // @kind(SyntaxKind.JsxOpeningElement)
     export interface JsxOpeningElement extends Expression {
         _openingElementBrand?: any;
-        tagName: LeftHandSideExpression;
+        tagName: JsxTagNameExpression;
         attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>;
     }
 
@@ -1073,7 +1075,7 @@ namespace ts {
 
     // @kind(SyntaxKind.JsxClosingElement)
     export interface JsxClosingElement extends Node {
-        tagName: LeftHandSideExpression;
+        tagName: JsxTagNameExpression;
     }
 
     // @kind(SyntaxKind.JsxExpression)

diff --git a/tests/cases/conformance/jsx/tsxDynamicTagName7.tsx b/tests/cases/conformance/jsx/tsxDynamicTagName7.tsx
@@ -0,0 +1,19 @@
+// @jsx: preserve
+
+//@filename: react.d.ts
+declare module 'react' {
+	class Component<T, U> { }
+}
+
+//@filename: app.tsx
+import * as React from 'react';
+
+export class Text extends React.Component<{}, {}> {
+  _tagName: string = 'div';
+
+  render() {
+    return (
+      <this/>  // this should be an error
+    );
+  }
+}
diff --git a/tests/cases/conformance/jsx/tsxDynamicTagName8.tsx b/tests/cases/conformance/jsx/tsxDynamicTagName8.tsx
@@ -0,0 +1,19 @@
+// @jsx: preserve
+
+//@filename: react.d.ts
+declare module 'react' {
+	class Component<T, U> { }
+}
+
+//@filename: app.tsx
+import * as React from 'react';
+
+export class Text extends React.Component<{}, {}> {
+  _tagName: string = 'div';
+
+  render() {
+    return (
+      <this._tagName> Hello world </this._tagName>
+    );
+  }
+}
diff --git a/tests/cases/conformance/jsx/tsxUnionTypeComponent2.tsx b/tests/cases/conformance/jsx/tsxUnionTypeComponent2.tsx
@@ -5,9 +5,9 @@
 
 import React = require('react');
 
-type Invalid1 = React.ComponentClass<any> | string;
+type Invalid1 = React.ComponentClass<any> | number;
 
-const X: Invalid1 = "Should fail to construct";
+const X: Invalid1 = 1;
 
 <X />;