Rename resolvedJsxType to be resolvedJSXElementAttributesType for clarification

Kanchalai Tanglertsampan · Kanchalai Tanglertsampan · commit a0793ae80f02 · 2016-10-03T10:08:03.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -10870,17 +10870,22 @@ namespace ts {
         }
 
         /**
-         * Given React element instance type and the class type, resolve the Jsx type
-         * Pass elemType to handle individual type in the union typed element type.
-         */
-        function getResolvedJsxType(node: JsxOpeningLikeElement, elemType?: Type, elemClassType?: Type): Type {
+         * Resolve attributes type of the given node. The function is intended to initally be called from getJsxElementAttributesType which already handle JSX-intrinsic-element.
+         * @param node a non-instrinsic JSXOPeningLikeElement
+         * @param elemType an instance type of the given node
+         * @param elemClassType a JSX-ElementClass type. This is a result of looking up ElementClass interface in the JSX global (imported from react.d.ts)
+         * @return attributes'type if able to resolve the type of node
+         *         anyType if there is no type ElementAttributesProperty or there is an error
+         *         emptyObjectType if there is no "prop" in the element instance type
+         **/
+        function resolveJsxElementAttributesType(node: JsxOpeningLikeElement, elemType?: Type, elemClassType?: Type): Type {
             if (!elemType) {
                 elemType = checkExpression(node.tagName);
             }
             if (elemType.flags & TypeFlags.Union) {
                 const types = (<TypeOperatorType>elemType).types;
                 return getUnionType(types.map(type => {
-                    return getResolvedJsxType(node, type, elemClassType);
+                    return resolveJsxElementAttributesType(node, type, elemClassType);
                 }), /*subtypeReduction*/ true);
             }
 
@@ -10990,30 +10995,31 @@ namespace ts {
         }
 
         /**
-         * Given an opening/self-closing element, get the 'element attributes type', i.e. the type that tells
-         * us which attributes are valid on a given element.
+         * Get the attributes type which is the type that indicate which attributes are valid on the given JSXOpeningLikeElement.
+         * @param node a JSXOpeningLikeElement node
+         * @return an attributes type of the given node
          */
         function getJsxElementAttributesType(node: JsxOpeningLikeElement): Type {
             const links = getNodeLinks(node);
-            if (!links.resolvedJsxType) {
+            if (!links.resolvedJsxElementAttributesType) {
                 if (isJsxIntrinsicIdentifier(node.tagName)) {
                     const symbol = getIntrinsicTagSymbol(node);
                     if (links.jsxFlags & JsxFlags.IntrinsicNamedElement) {
-                        return links.resolvedJsxType = getTypeOfSymbol(symbol);
+                        return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol);
                     }
                     else if (links.jsxFlags & JsxFlags.IntrinsicIndexedElement) {
-                        return links.resolvedJsxType = getIndexInfoOfSymbol(symbol, IndexKind.String).type;
+                        return links.resolvedJsxElementAttributesType = getIndexInfoOfSymbol(symbol, IndexKind.String).type;
                     }
                     else {
-                        return links.resolvedJsxType = unknownType;
+                        return links.resolvedJsxElementAttributesType = unknownType;
                     }
                 }
                 else {
                     const elemClassType = getJsxGlobalElementClassType();
-                    return links.resolvedJsxType = getResolvedJsxType(node, undefined, elemClassType);
+                    return links.resolvedJsxElementAttributesType = resolveJsxElementAttributesType(node, undefined, elemClassType);
                 }
             }
-            return links.resolvedJsxType;
+            return links.resolvedJsxElementAttributesType;
         }
 
         /**
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2363,7 +2363,7 @@ namespace ts {
         isVisible?: boolean;              // Is this node visible
         hasReportedStatementInAmbientContext?: boolean;  // Cache boolean if we report statements in ambient context
         jsxFlags?: JsxFlags;              // flags for knowing what kind of element/attributes we're dealing with
-        resolvedJsxType?: Type;           // resolved element attributes type of a JSX openinglike element
+        resolvedJsxElementAttributesType?: Type;  // resolved element attributes type of a JSX openinglike element
         hasSuperCall?: boolean;           // recorded result when we try to find super-call. We only try to find one if this flag is undefined, indicating that we haven't made an attempt.
         superCall?: ExpressionStatement;  // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing
         switchTypes?: Type[];             // Cached array of switch case expression types
