Update for style 🎩

RyanCavanaugh · RyanCavanaugh · commit 042f1fc4a8ca · 2015-06-29T09:07:12.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -6764,7 +6764,7 @@ namespace ts {
          */
         function isUnhyphenatedJsxName(name: string) {
             // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers
-            return name.indexOf('-') < 0;
+            return name.indexOf("-") < 0;
         }
 
         /**
@@ -6961,7 +6961,7 @@ namespace ts {
         /// e.g. "props" for React.d.ts,
         /// or 'undefined' if ElementAttributesPropery doesn't exist (which means all
         ///     non-intrinsic elements' attributes type is 'any'),
-        /// or '' if it has 0 properties (which means all
+        /// or '' if it has 0 properties (which means every
         ///     non-instrinsic elements' attributes type is the element instance type)
         function getJsxElementPropertiesName() {
             // JSX
@@ -6976,7 +6976,7 @@ namespace ts {
             if (attribProperties) {
                 // Element Attributes has zero properties, so the element attributes type will be the class instance type
                 if (attribProperties.length === 0) {
-                    return '';
+                    return "";
                 }
                 // Element Attributes has one property, so the element attributes type will be the type of the corresponding
                 // property of the class instance type
@@ -7016,7 +7016,7 @@ namespace ts {
                         // There is no type ElementAttributesProperty, return 'any'
                         return links.resolvedJsxType = anyType;
                     }
-                    else if (propsName === '') {
+                    else if (propsName === "") {
                         // If there is no e.g. 'props' member in ElementAttributesProperty, use the element class type instead
                         return links.resolvedJsxType = elemInstanceType;
                     }
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -1140,80 +1140,80 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                 /// Emit an name/value pair for an attribute (e.g. "x: 3")
                 function emitJsxAttribute(node: JsxAttribute) {
                     emitAttributeName(node.name);
-                    write(': ');
+                    write(": ");
                     if (node.initializer) {
                         emit(node.initializer);
                     }
                     else {
-                        write('true');
+                        write("true");
                     }
                 }
 
                 function emitJsxElement(openingNode: JsxOpeningLikeElement, children?: JsxChild[]) {
                     // Call React.createElement(tag, ...
                     emitLeadingComments(openingNode);
-                    write('React.createElement(');
+                    write("React.createElement(");
                     emitTagName(openingNode.tagName);
-                    write(', ');
+                    write(", ");
 
                     // Attribute list
                     if (openingNode.attributes.length === 0) {
-                        // When there are no attributes, React wants 'null'
-                        write('null');
+                        // When there are no attributes, React wants "null"
+                        write("null");
                     }
                     else {
                         // Either emit one big object literal (no spread attribs), or
                         // a call to React.__spread
                         let attrs = openingNode.attributes;
                         if (attrs.some(attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) {
-                            write('React.__spread(');
+                            write("React.__spread(");
 
                             let haveOpenedObjectLiteral = false;
                             for (let i = 0; i < attrs.length; i++) {
                                 if (attrs[i].kind === SyntaxKind.JsxSpreadAttribute) {
                                     // If this is the first argument, we need to emit a {} as the first argument
                                     if (i === 0) {
-                                        write('{}, ');
+                                        write("{}, ");
                                     }
 
                                     if (haveOpenedObjectLiteral) {
-                                        write('}');
+                                        write("}");
                                         haveOpenedObjectLiteral = false;
                                     }
                                     if (i > 0) {
-                                        write(', ');
+                                        write(", ");
                                     }
                                     emit((<JsxSpreadAttribute>attrs[i]).expression);
                                 }
                                 else {
                                     Debug.assert(attrs[i].kind === SyntaxKind.JsxAttribute);
                                     if (haveOpenedObjectLiteral) {
-                                        write(', ');
+                                        write(", ");
                                     }
                                     else {
                                         haveOpenedObjectLiteral = true;
                                         if (i > 0) {
-                                            write(', ');
+                                            write(", ");
                                         }
-                                        write('{');
+                                        write("{");
                                     }
                                     emitJsxAttribute(<JsxAttribute>attrs[i]);
                                 }
                             }
-                            if (haveOpenedObjectLiteral) write('}');
+                            if (haveOpenedObjectLiteral) write("}");
 
-                            write(')'); // closing paren to React.__spread(
+                            write(")"); // closing paren to React.__spread(
                         }
                         else {
                             // One object literal with all the attributes in them
-                            write('{');
+                            write("{");
                             for (var i = 0; i < attrs.length; i++) {
                                 if (i > 0) {
-                                    write(', ');
+                                    write(", ");
                                 }
                                 emitJsxAttribute(<JsxAttribute>attrs[i]);
                             }
-                            write('}');
+                            write("}");
                         }
                     }
 
@@ -1235,15 +1235,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                                 }
                             }
                             else {
-                                write(', ');
+                                write(", ");
                                 emit(children[i]);
                             }
 
                         }
                     }
 
                     // Closing paren
-                    write(')'); // closes 'React.createElement('
+                    write(")"); // closes "React.createElement("
                     emitTrailingComments(openingNode);
                 }
 
@@ -1259,20 +1259,20 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             function jsxEmitPreserve(node: JsxElement|JsxSelfClosingElement) {
                 function emitJsxAttribute(node: JsxAttribute) {
                     emit(node.name);
-                    write('=');
+                    write("=");
                     emit(node.initializer);
                 }
 
                 function emitJsxSpreadAttribute(node: JsxSpreadAttribute) {
-                    write('{...');
+                    write("{...");
                     emit(node.expression);
-                    write('}');
+                    write("}");
                 }
 
                 function emitAttributes(attribs: NodeArray<JsxAttribute|JsxSpreadAttribute>) {
                     for (let i = 0, n = attribs.length; i < n; i++) {
                         if (i > 0) {
-                            write(' ');
+                            write(" ");
                         }
 
                         if (attribs[i].kind === SyntaxKind.JsxSpreadAttribute) {
@@ -1286,26 +1286,26 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                 }
 
                 function emitJsxOpeningOrSelfClosingElement(node: JsxOpeningElement|JsxSelfClosingElement) {
-                    write('<');
+                    write("<");
                     emit(node.tagName);
                     if (node.attributes.length > 0 || (node.kind === SyntaxKind.JsxSelfClosingElement)) {
-                        write(' ');
+                        write(" ");
                     }
 
                     emitAttributes(node.attributes);
 
                     if (node.kind === SyntaxKind.JsxSelfClosingElement) {
-                        write('/>');
+                        write("/>");
                     }
                     else {
-                        write('>');
+                        write(">");
                     }
                 }
 
                 function emitJsxClosingElement(node: JsxClosingElement) {
-                    write('</');
+                    write("</");
                     emit(node.tagName);
-                    write('>');
+                    write(">");
                 }
 
                 function emitJsxElement(node: JsxElement) {

Original file line number	Diff line number	Diff line change
`@@ -1140,80 +1140,80 @@ var __param = (this && this.__param) \|\| function (paramIndex, decorator) {`
`1140`	`1140`	`/// Emit an name/value pair for an attribute (e.g. "x: 3")`
`1141`	`1141`	`function emitJsxAttribute(node: JsxAttribute) {`
`1142`	`1142`	`emitAttributeName(node.name);`
`1143`		`- write(': ');`
	`1143`	`+ write(": ");`
`1144`	`1144`	`if (node.initializer) {`
`1145`	`1145`	`emit(node.initializer);`
`1146`	`1146`	`}`
`1147`	`1147`	`else {`
`1148`		`- write('true');`
	`1148`	`+ write("true");`
`1149`	`1149`	`}`
`1150`	`1150`	`}`
`1151`	`1151`
`1152`	`1152`	`function emitJsxElement(openingNode: JsxOpeningLikeElement, children?: JsxChild[]) {`
`1153`	`1153`	`// Call React.createElement(tag, ...`
`1154`	`1154`	`emitLeadingComments(openingNode);`
`1155`		`- write('React.createElement(');`
	`1155`	`+ write("React.createElement(");`
`1156`	`1156`	`emitTagName(openingNode.tagName);`
`1157`		`- write(', ');`
	`1157`	`+ write(", ");`
`1158`	`1158`
`1159`	`1159`	`// Attribute list`
`1160`	`1160`	`if (openingNode.attributes.length === 0) {`
`1161`		`- // When there are no attributes, React wants 'null'`
`1162`		`- write('null');`
	`1161`	`+ // When there are no attributes, React wants "null"`
	`1162`	`+ write("null");`
`1163`	`1163`	`}`
`1164`	`1164`	`else {`
`1165`	`1165`	`// Either emit one big object literal (no spread attribs), or`
`1166`	`1166`	`// a call to React.__spread`
`1167`	`1167`	`let attrs = openingNode.attributes;`
`1168`	`1168`	`if (attrs.some(attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) {`
`1169`		`- write('React.__spread(');`
	`1169`	`+ write("React.__spread(");`
`1170`	`1170`
`1171`	`1171`	`let haveOpenedObjectLiteral = false;`
`1172`	`1172`	`for (let i = 0; i < attrs.length; i++) {`
`1173`	`1173`	`if (attrs[i].kind === SyntaxKind.JsxSpreadAttribute) {`
`1174`	`1174`	`// If this is the first argument, we need to emit a {} as the first argument`
`1175`	`1175`	`if (i === 0) {`
`1176`		`- write('{}, ');`
	`1176`	`+ write("{}, ");`
`1177`	`1177`	`}`
`1178`	`1178`
`1179`	`1179`	`if (haveOpenedObjectLiteral) {`
`1180`		`- write('}');`
	`1180`	`+ write("}");`
`1181`	`1181`	`haveOpenedObjectLiteral = false;`
`1182`	`1182`	`}`
`1183`	`1183`	`if (i > 0) {`
`1184`		`- write(', ');`
	`1184`	`+ write(", ");`
`1185`	`1185`	`}`
`1186`	`1186`	`emit((<JsxSpreadAttribute>attrs[i]).expression);`
`1187`	`1187`	`}`
`1188`	`1188`	`else {`
`1189`	`1189`	`Debug.assert(attrs[i].kind === SyntaxKind.JsxAttribute);`
`1190`	`1190`	`if (haveOpenedObjectLiteral) {`
`1191`		`- write(', ');`
	`1191`	`+ write(", ");`
`1192`	`1192`	`}`
`1193`	`1193`	`else {`
`1194`	`1194`	`haveOpenedObjectLiteral = true;`
`1195`	`1195`	`if (i > 0) {`
`1196`		`- write(', ');`
	`1196`	`+ write(", ");`
`1197`	`1197`	`}`
`1198`		`- write('{');`
	`1198`	`+ write("{");`
`1199`	`1199`	`}`
`1200`	`1200`	`emitJsxAttribute(<JsxAttribute>attrs[i]);`
`1201`	`1201`	`}`
`1202`	`1202`	`}`
`1203`		`- if (haveOpenedObjectLiteral) write('}');`
	`1203`	`+ if (haveOpenedObjectLiteral) write("}");`
`1204`	`1204`
`1205`		`- write(')'); // closing paren to React.__spread(`
	`1205`	`+ write(")"); // closing paren to React.__spread(`
`1206`	`1206`	`}`
`1207`	`1207`	`else {`
`1208`	`1208`	`// One object literal with all the attributes in them`
`1209`		`- write('{');`
	`1209`	`+ write("{");`
`1210`	`1210`	`for (var i = 0; i < attrs.length; i++) {`
`1211`	`1211`	`if (i > 0) {`
`1212`		`- write(', ');`
	`1212`	`+ write(", ");`
`1213`	`1213`	`}`
`1214`	`1214`	`emitJsxAttribute(<JsxAttribute>attrs[i]);`
`1215`	`1215`	`}`
`1216`		`- write('}');`
	`1216`	`+ write("}");`
`1217`	`1217`	`}`
`1218`	`1218`	`}`
`1219`	`1219`
`@@ -1235,15 +1235,15 @@ var __param = (this && this.__param) \|\| function (paramIndex, decorator) {`
`1235`	`1235`	`}`
`1236`	`1236`	`}`
`1237`	`1237`	`else {`
`1238`		`- write(', ');`
	`1238`	`+ write(", ");`
`1239`	`1239`	`emit(children[i]);`
`1240`	`1240`	`}`
`1241`	`1241`
`1242`	`1242`	`}`
`1243`	`1243`	`}`
`1244`	`1244`
`1245`	`1245`	`// Closing paren`
`1246`		`- write(')'); // closes 'React.createElement('`
	`1246`	`+ write(")"); // closes "React.createElement("`
`1247`	`1247`	`emitTrailingComments(openingNode);`
`1248`	`1248`	`}`
`1249`	`1249`
`@@ -1259,20 +1259,20 @@ var __param = (this && this.__param) \|\| function (paramIndex, decorator) {`
`1259`	`1259`	`function jsxEmitPreserve(node: JsxElement\|JsxSelfClosingElement) {`
`1260`	`1260`	`function emitJsxAttribute(node: JsxAttribute) {`
`1261`	`1261`	`emit(node.name);`
`1262`		`- write('=');`
	`1262`	`+ write("=");`
`1263`	`1263`	`emit(node.initializer);`
`1264`	`1264`	`}`
`1265`	`1265`
`1266`	`1266`	`function emitJsxSpreadAttribute(node: JsxSpreadAttribute) {`
`1267`		`- write('{...');`
	`1267`	`+ write("{...");`
`1268`	`1268`	`emit(node.expression);`
`1269`		`- write('}');`
	`1269`	`+ write("}");`
`1270`	`1270`	`}`
`1271`	`1271`
`1272`	`1272`	`function emitAttributes(attribs: NodeArray<JsxAttribute\|JsxSpreadAttribute>) {`
`1273`	`1273`	`for (let i = 0, n = attribs.length; i < n; i++) {`
`1274`	`1274`	`if (i > 0) {`
`1275`		`- write(' ');`
	`1275`	`+ write(" ");`
`1276`	`1276`	`}`
`1277`	`1277`
`1278`	`1278`	`if (attribs[i].kind === SyntaxKind.JsxSpreadAttribute) {`
`@@ -1286,26 +1286,26 @@ var __param = (this && this.__param) \|\| function (paramIndex, decorator) {`
`1286`	`1286`	`}`
`1287`	`1287`
`1288`	`1288`	`function emitJsxOpeningOrSelfClosingElement(node: JsxOpeningElement\|JsxSelfClosingElement) {`
`1289`		`- write('<');`
	`1289`	`+ write("<");`
`1290`	`1290`	`emit(node.tagName);`
`1291`	`1291`	`if (node.attributes.length > 0 \|\| (node.kind === SyntaxKind.JsxSelfClosingElement)) {`
`1292`		`- write(' ');`
	`1292`	`+ write(" ");`
`1293`	`1293`	`}`
`1294`	`1294`
`1295`	`1295`	`emitAttributes(node.attributes);`
`1296`	`1296`
`1297`	`1297`	`if (node.kind === SyntaxKind.JsxSelfClosingElement) {`
`1298`		`- write('/>');`
	`1298`	`+ write("/>");`
`1299`	`1299`	`}`
`1300`	`1300`	`else {`
`1301`		`- write('>');`
	`1301`	`+ write(">");`
`1302`	`1302`	`}`
`1303`	`1303`	`}`
`1304`	`1304`
`1305`	`1305`	`function emitJsxClosingElement(node: JsxClosingElement) {`
`1306`		`- write('</');`
	`1306`	`+ write("</");`
`1307`	`1307`	`emit(node.tagName);`
`1308`		`- write('>');`
	`1308`	`+ write(">");`
`1309`	`1309`	`}`
`1310`	`1310`
`1311`	`1311`	`function emitJsxElement(node: JsxElement) {`