Merge pull request #15160 from Microsoft/master-jsxChildren

[Master] Type checking JSX children

Author: yuit

src/compiler/checker.ts

@@ -2119,6 +2119,10 @@
  "category": "Error",
  "code": 2709
  },
+ "'{0}' are specified twice. The attribute named '{0}' will be overwritten.": {
+ "category": "Error",
+ "code": 2710
+ },
 
  "Import declaration '{0}' is using private name '{1}'.": {
  "category": "Error",

src/compiler/diagnosticMessages.json

@@ -2457,7 +2457,7 @@ namespace ts {
  let indentation: number;
  for (const line of lines) {
  for (let i = 0; i < line.length && (indentation === undefined || i < indentation); i++) {
- if (!isWhiteSpace(line.charCodeAt(i))) {
+ if (!isWhiteSpaceLike(line.charCodeAt(i))) {
  if (indentation === undefined || i < indentation) {
  indentation = i;
  break;

src/compiler/emitter.ts

@@ -3828,13 +3828,15 @@ namespace ts {
 
  function parseJsxText(): JsxText {
  const node = <JsxText>createNode(SyntaxKind.JsxText, scanner.getStartPos());
+ node.containsOnlyWhiteSpaces = currentToken === SyntaxKind.JsxTextAllWhiteSpaces;
  currentToken = scanner.scanJsxToken();
  return finishNode(node);
  }
 
  function parseJsxChild(): JsxChild {
  switch (token()) {
  case SyntaxKind.JsxText:
+ case SyntaxKind.JsxTextAllWhiteSpaces:
  return parseJsxText();
  case SyntaxKind.OpenBraceToken:
  return parseJsxExpression(/*inExpressionContext*/ false);
@@ -3864,7 +3866,10 @@ namespace ts {
  else if (token() === SyntaxKind.ConflictMarkerTrivia) {
  break;
  }
- result.push(parseJsxChild());
+ const child = parseJsxChild();
+ if (child) {
+ result.push(child);
+ }
  }
 
  result.end = scanner.getTokenPos();

src/compiler/parser.ts

@@ -367,7 +367,7 @@ namespace ts {
  return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
  }
 
- export function isWhiteSpace(ch: number): boolean {
+ export function isWhiteSpaceLike(ch: number): boolean {
  return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
  }
 
@@ -512,7 +512,7 @@ namespace ts {
  break;
 
  default:
- if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpace(ch))) {
+ if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpaceLike(ch))) {
  pos++;
  continue;
  }
@@ -694,7 +694,7 @@ namespace ts {
  }
  break scan;
  default:
- if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpace(ch))) {
+ if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpaceLike(ch))) {
  if (hasPendingCommentRange && isLineBreak(ch)) {
  pendingHasTrailingNewLine = true;
  }
@@ -1727,8 +1727,12 @@ namespace ts {
  return token = SyntaxKind.OpenBraceToken;
  }
 
+ // First non-whitespace character on this line.
+ let firstNonWhitespace = 0;
+ // These initial values are special because the first line is:
+ // firstNonWhitespace = 0 to indicate that we want leading whitspace,
+
  while (pos < end) {
- pos++;
  char = text.charCodeAt(pos);
  if (char === CharacterCodes.openBrace) {
  break;
@@ -1740,8 +1744,23 @@ namespace ts {
  }
  break;
  }
+
+ // FirstNonWhitespace is 0, then we only see whitespaces so far. If we see a linebreak, we want to ignore that whitespaces.
+ // i.e (- : whitespace)
+ // <div>----
+ // </div> becomes <div></div>
+ //
+ // <div>----</div> becomes <div>----</div>
+ if (isLineBreak(char) && firstNonWhitespace === 0) {
+ firstNonWhitespace = -1;
+ }
+ else if (!isWhiteSpaceLike(char)) {
+ firstNonWhitespace = pos;
+ }
+ pos++;
  }
- return token = SyntaxKind.JsxText;
+
+ return firstNonWhitespace === -1 ? SyntaxKind.JsxTextAllWhiteSpaces : SyntaxKind.JsxText;
  }
 
  // Scans a JSX identifier; these differ from normal identifiers in that

src/compiler/scanner.ts

@@ -10,7 +10,7 @@ namespace ts {
 
  /** ES6 Map interface. */
  export interface Map<T> {
- get(key: string): T;
+ get(key: string): T | undefined;
  has(key: string): boolean;
  set(key: string, value: T): this;
  delete(key: string): boolean;
@@ -65,6 +65,7 @@ namespace ts {
  NumericLiteral,
  StringLiteral,
  JsxText,
+ JsxTextAllWhiteSpaces,
  RegularExpressionLiteral,
  NoSubstitutionTemplateLiteral,
  // Pseudo-literals
@@ -1572,6 +1573,7 @@ namespace ts {
 
  export interface JsxText extends Node {
  kind: SyntaxKind.JsxText;
+ containsOnlyWhiteSpaces: boolean;
  parent?: JsxElement;
  }
 

src/compiler/types.ts

@@ -54,7 +54,7 @@ namespace ts.formatting {
  let current = position;
  while (current > 0) {
  const char = sourceFile.text.charCodeAt(current);
- if (!isWhiteSpace(char)) {
+ if (!isWhiteSpaceLike(char)) {
  break;
  }
  current--;

src/services/formatting/smartIndenter.ts

@@ -608,7 +608,7 @@ namespace ts.textChanges {
  if (force || !isTrivia(s)) {
  this.lastNonTriviaPosition = this.writer.getTextPos();
  let i = 0;
- while (isWhiteSpace(s.charCodeAt(s.length - i - 1))) {
+ while (isWhiteSpaceLike(s.charCodeAt(s.length - i - 1))) {
  i++;
  }
  // trim trailing whitespaces

src/services/textChanges.ts

@@ -1380,7 +1380,7 @@ namespace ts {
  }
 
  export function getFirstNonSpaceCharacterPosition(text: string, position: number) {
- while (isWhiteSpace(text.charCodeAt(position))) {
+ while (isWhiteSpaceLike(text.charCodeAt(position))) {
  position += 1;
  }
  return position;

src/services/utilities.ts

@@ -0,0 +1,39 @@
+//// [file.tsx]
+import React = require('react');
+
+interface Prop {
+ a: number,
+ b: string,
+ children: string | JSX.Element
+}
+
+function Comp(p: Prop) {
+ return <div>{p.b}</div>;
+}
+
+// OK
+let k = <Comp a={10} b="hi" children ="lol" />;
+let k1 =
+ <Comp a={10} b="hi">
+ hi hi hi!
+ </Comp>;
+let k2 =
+ <Comp a={10} b="hi">
+ <div>hi hi hi!</div>
+ </Comp>;
+
+//// [file.jsx]
+"use strict";
+exports.__esModule = true;
+var React = require("react");
+function Comp(p) {
+ return <div>{p.b}</div>;
+}
+// OK
+var k = <Comp a={10} b="hi" children="lol"/>;
+var k1 = <Comp a={10} b="hi">
+ hi hi hi!
+ </Comp>;
+var k2 = <Comp a={10} b="hi">
+ <div>hi hi hi!</div>
+ </Comp>;