Rename "babylon" to "@babel/parser" (#7937) 🎉

packages/babel-parser/src/plugins/estree.js

@@ -0,0 +1,363 @@
+// @flow
+
+import { types as tt, TokenType } from "../tokenizer/types";
+import type Parser from "../parser";
+import * as N from "../types";
+import type { Pos, Position } from "../util/location";
+
+function isSimpleProperty(node: N.Node): boolean {
+  return (
+    node != null &&
+    node.type === "Property" &&
+    node.kind === "init" &&
+    node.method === false
+  );
+}
+
+export default (superClass: Class<Parser>): Class<Parser> =>
+  class extends superClass {
+    estreeParseRegExpLiteral({ pattern, flags }: N.RegExpLiteral): N.Node {
+      let regex = null;
+      try {
+        regex = new RegExp(pattern, flags);
+      } catch (e) {
+        // In environments that don't support these flags value will
+        // be null as the regex can't be represented natively.
+      }
+      const node = this.estreeParseLiteral(regex);
+      node.regex = { pattern, flags };
+
+      return node;
+    }
+
+    estreeParseLiteral(value: any): N.Node {
+      return this.parseLiteral(value, "Literal");
+    }
+
+    directiveToStmt(directive: N.Directive): N.ExpressionStatement {
+      const directiveLiteral = directive.value;
+
+      const stmt = this.startNodeAt(directive.start, directive.loc.start);
+      const expression = this.startNodeAt(
+        directiveLiteral.start,
+        directiveLiteral.loc.start,
+      );
+
+      expression.value = directiveLiteral.value;
+      expression.raw = directiveLiteral.extra.raw;
+
+      stmt.expression = this.finishNodeAt(
+        expression,
+        "Literal",
+        directiveLiteral.end,
+        directiveLiteral.loc.end,
+      );
+      stmt.directive = directiveLiteral.extra.raw.slice(1, -1);
+
+      return this.finishNodeAt(
+        stmt,
+        "ExpressionStatement",
+        directive.end,
+        directive.loc.end,
+      );
+    }
+
+    // ==================================
+    // Overrides
+    // ==================================
+
+    initFunction(
+      node: N.BodilessFunctionOrMethodBase,
+      isAsync: ?boolean,
+    ): void {
+      super.initFunction(node, isAsync);
+      node.expression = false;
+    }
+
+    checkDeclaration(node: N.Pattern | N.ObjectProperty): void {
+      if (isSimpleProperty(node)) {
+        this.checkDeclaration(((node: any): N.EstreeProperty).value);
+      } else {
+        super.checkDeclaration(node);
+      }
+    }
+
+    checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {
+      const prop = ((method: any): N.EstreeProperty | N.EstreeMethodDefinition);
+      const paramCount = prop.kind === "get" ? 0 : 1;
+      const start = prop.start;
+      if (prop.value.params.length !== paramCount) {
+        if (prop.kind === "get") {
+          this.raise(start, "getter must not have any formal parameters");
+        } else {
+          this.raise(start, "setter must have exactly one formal parameter");
+        }
+      }
+
+      if (prop.kind === "set" && prop.value.params[0].type === "RestElement") {
+        this.raise(
+          start,
+          "setter function argument must not be a rest parameter",
+        );
+      }
+    }
+
+    checkLVal(
+      expr: N.Expression,
+      isBinding: ?boolean,
+      checkClashes: ?{ [key: string]: boolean },
+      contextDescription: string,
+    ): void {
+      switch (expr.type) {
+        case "ObjectPattern":
+          expr.properties.forEach(prop => {
+            this.checkLVal(
+              prop.type === "Property" ? prop.value : prop,
+              isBinding,
+              checkClashes,
+              "object destructuring pattern",
+            );
+          });
+          break;
+        default:
+          super.checkLVal(expr, isBinding, checkClashes, contextDescription);
+      }
+    }
+
+    checkPropClash(
+      prop: N.ObjectMember,
+      propHash: { [key: string]: boolean },
+    ): void {
+      if (prop.computed || !isSimpleProperty(prop)) return;
+
+      const key = prop.key;
+      // It is either an Identifier or a String/NumericLiteral
+      const name = key.type === "Identifier" ? key.name : String(key.value);
+
+      if (name === "__proto__") {
+        if (propHash.proto) {
+          this.raise(key.start, "Redefinition of __proto__ property");
+        }
+        propHash.proto = true;
+      }
+    }
+
+    isStrictBody(node: { body: N.BlockStatement }): boolean {
+      const isBlockStatement = node.body.type === "BlockStatement";
+
+      if (isBlockStatement && node.body.body.length > 0) {
+        for (const directive of node.body.body) {
+          if (
+            directive.type === "ExpressionStatement" &&
+            directive.expression.type === "Literal"
+          ) {
+            if (directive.expression.value === "use strict") return true;
+          } else {
+            // Break for the first non literal expression
+            break;
+          }
+        }
+      }
+
+      return false;
+    }
+
+    isValidDirective(stmt: N.Statement): boolean {
+      return (
+        stmt.type === "ExpressionStatement" &&
+        stmt.expression.type === "Literal" &&
+        typeof stmt.expression.value === "string" &&
+        (!stmt.expression.extra || !stmt.expression.extra.parenthesized)
+      );
+    }
+
+    stmtToDirective(stmt: N.Statement): N.Directive {
+      const directive = super.stmtToDirective(stmt);
+      const value = stmt.expression.value;
+
+      // Reset value to the actual value as in estree mode we want
+      // the stmt to have the real value and not the raw value
+      directive.value.value = value;
+
+      return directive;
+    }
+
+    parseBlockBody(
+      node: N.BlockStatementLike,
+      allowDirectives: ?boolean,
+      topLevel: boolean,
+      end: TokenType,
+    ): void {
+      super.parseBlockBody(node, allowDirectives, topLevel, end);
+
+      const directiveStatements = node.directives.map(d =>
+        this.directiveToStmt(d),
+      );
+      node.body = directiveStatements.concat(node.body);
+      delete node.directives;
+    }
+
+    pushClassMethod(
+      classBody: N.ClassBody,
+      method: N.ClassMethod,
+      isGenerator: boolean,
+      isAsync: boolean,
+      isConstructor: boolean,
+    ): void {
+      this.parseMethod(
+        method,
+        isGenerator,
+        isAsync,
+        isConstructor,
+        "MethodDefinition",
+      );
+      if (method.typeParameters) {
+        // $FlowIgnore
+        method.value.typeParameters = method.typeParameters;
+        delete method.typeParameters;
+      }
+      classBody.body.push(method);
+    }
+
+    parseExprAtom(refShorthandDefaultPos?: ?Pos): N.Expression {
+      switch (this.state.type) {
+        case tt.regexp:
+          return this.estreeParseRegExpLiteral(this.state.value);
+
+        case tt.num:
+        case tt.string:
+          return this.estreeParseLiteral(this.state.value);
+
+        case tt._null:
+          return this.estreeParseLiteral(null);
+
+        case tt._true:
+          return this.estreeParseLiteral(true);
+
+        case tt._false:
+          return this.estreeParseLiteral(false);
+
+        default:
+          return super.parseExprAtom(refShorthandDefaultPos);
+      }
+    }
+
+    parseLiteral<T: N.Literal>(
+      value: any,
+      type: /*T["kind"]*/ string,
+      startPos?: number,
+      startLoc?: Position,
+    ): T {
+      const node = super.parseLiteral(value, type, startPos, startLoc);
+      node.raw = node.extra.raw;
+      delete node.extra;
+
+      return node;
+    }
+
+    parseFunctionBody(node: N.Function, allowExpression: ?boolean): void {
+      super.parseFunctionBody(node, allowExpression);
+      node.expression = node.body.type !== "BlockStatement";
+    }
+
+    parseMethod<T: N.MethodLike>(
+      node: T,
+      isGenerator: boolean,
+      isAsync: boolean,
+      isConstructor: boolean,
+      type: string,
+    ): T {
+      let funcNode = this.startNode();
+      funcNode.kind = node.kind; // provide kind, so super method correctly sets state
+      funcNode = super.parseMethod(
+        funcNode,
+        isGenerator,
+        isAsync,
+        isConstructor,
+        "FunctionExpression",
+      );
+      delete funcNode.kind;
+      // $FlowIgnore
+      node.value = funcNode;
+
+      return this.finishNode(node, type);
+    }
+
+    parseObjectMethod(
+      prop: N.ObjectMethod,
+      isGenerator: boolean,
+      isAsync: boolean,
+      isPattern: boolean,
+      containsEsc: boolean,
+    ): ?N.ObjectMethod {
+      const node: N.EstreeProperty = (super.parseObjectMethod(
+        prop,
+        isGenerator,
+        isAsync,
+        isPattern,
+        containsEsc,
+      ): any);
+
+      if (node) {
+        node.type = "Property";
+        if (node.kind === "method") node.kind = "init";
+        node.shorthand = false;
+      }
+
+      return (node: any);
+    }
+
+    parseObjectProperty(
+      prop: N.ObjectProperty,
+      startPos: ?number,
+      startLoc: ?Position,
+      isPattern: boolean,
+      refShorthandDefaultPos: ?Pos,
+    ): ?N.ObjectProperty {
+      const node: N.EstreeProperty = (super.parseObjectProperty(
+        prop,
+        startPos,
+        startLoc,
+        isPattern,
+        refShorthandDefaultPos,
+      ): any);
+
+      if (node) {
+        node.kind = "init";
+        node.type = "Property";
+      }
+
+      return (node: any);
+    }
+
+    toAssignable(
+      node: N.Node,
+      isBinding: ?boolean,
+      contextDescription: string,
+    ): N.Node {
+      if (isSimpleProperty(node)) {
+        this.toAssignable(node.value, isBinding, contextDescription);
+
+        return node;
+      }
+
+      return super.toAssignable(node, isBinding, contextDescription);
+    }
+
+    toAssignableObjectExpressionProp(
+      prop: N.Node,
+      isBinding: ?boolean,
+      isLast: boolean,
+    ) {
+      if (prop.kind === "get" || prop.kind === "set") {
+        this.raise(
+          prop.key.start,
+          "Object pattern can't contain getter or setter",
+        );
+      } else if (prop.method) {
+        this.raise(prop.key.start, "Object pattern can't contain methods");
+      } else {
+        super.toAssignableObjectExpressionProp(prop, isBinding, isLast);
+      }
+    }
+  };

packages/babel-parser/src/plugins/jsx/index.js

@@ -0,0 +1,561 @@
+// @flow
+
+import * as charCodes from "charcodes";
+
+import XHTMLEntities from "./xhtml";
+import type Parser from "../../parser";
+import { TokenType, types as tt } from "../../tokenizer/types";
+import { TokContext, types as tc } from "../../tokenizer/context";
+import * as N from "../../types";
+import { isIdentifierChar, isIdentifierStart } from "../../util/identifier";
+import type { Pos, Position } from "../../util/location";
+import { isNewLine } from "../../util/whitespace";
+
+const HEX_NUMBER = /^[\da-fA-F]+$/;
+const DECIMAL_NUMBER = /^\d+$/;
+
+tc.j_oTag = new TokContext("<tag", false);
+tc.j_cTag = new TokContext("</tag", false);
+tc.j_expr = new TokContext("<tag>...</tag>", true, true);
+
+tt.jsxName = new TokenType("jsxName");
+tt.jsxText = new TokenType("jsxText", { beforeExpr: true });
+tt.jsxTagStart = new TokenType("jsxTagStart", { startsExpr: true });
+tt.jsxTagEnd = new TokenType("jsxTagEnd");
+
+tt.jsxTagStart.updateContext = function() {
+  this.state.context.push(tc.j_expr); // treat as beginning of JSX expression
+  this.state.context.push(tc.j_oTag); // start opening tag context
+  this.state.exprAllowed = false;
+};
+
+tt.jsxTagEnd.updateContext = function(prevType) {
+  const out = this.state.context.pop();
+  if ((out === tc.j_oTag && prevType === tt.slash) || out === tc.j_cTag) {
+    this.state.context.pop();
+    this.state.exprAllowed = this.curContext() === tc.j_expr;
+  } else {
+    this.state.exprAllowed = true;
+  }
+};
+
+function isFragment(object: ?N.JSXElement): boolean {
+  return object
+    ? object.type === "JSXOpeningFragment" ||
+        object.type === "JSXClosingFragment"
+    : false;
+}
+
+// Transforms JSX element name to string.
+
+function getQualifiedJSXName(
+  object: N.JSXIdentifier | N.JSXNamespacedName | N.JSXMemberExpression,
+): string {
+  if (object.type === "JSXIdentifier") {
+    return object.name;
+  }
+
+  if (object.type === "JSXNamespacedName") {
+    return object.namespace.name + ":" + object.name.name;
+  }
+
+  if (object.type === "JSXMemberExpression") {
+    return (
+      getQualifiedJSXName(object.object) +
+      "." +
+      getQualifiedJSXName(object.property)
+    );
+  }
+
+  // istanbul ignore next
+  throw new Error("Node had unexpected type: " + object.type);
+}
+
+export default (superClass: Class<Parser>): Class<Parser> =>
+  class extends superClass {
+    // Reads inline JSX contents token.
+
+    jsxReadToken(): void {
+      let out = "";
+      let chunkStart = this.state.pos;
+      for (;;) {
+        if (this.state.pos >= this.input.length) {
+          this.raise(this.state.start, "Unterminated JSX contents");
+        }
+
+        const ch = this.input.charCodeAt(this.state.pos);
+
+        switch (ch) {
+          case charCodes.lessThan:
+          case charCodes.leftCurlyBrace:
+            if (this.state.pos === this.state.start) {
+              if (ch === charCodes.lessThan && this.state.exprAllowed) {
+                ++this.state.pos;
+                return this.finishToken(tt.jsxTagStart);
+              }
+              return this.getTokenFromCode(ch);
+            }
+            out += this.input.slice(chunkStart, this.state.pos);
+            return this.finishToken(tt.jsxText, out);
+
+          case charCodes.ampersand:
+            out += this.input.slice(chunkStart, this.state.pos);
+            out += this.jsxReadEntity();
+            chunkStart = this.state.pos;
+            break;
+
+          default:
+            if (isNewLine(ch)) {
+              out += this.input.slice(chunkStart, this.state.pos);
+              out += this.jsxReadNewLine(true);
+              chunkStart = this.state.pos;
+            } else {
+              ++this.state.pos;
+            }
+        }
+      }
+    }
+
+    jsxReadNewLine(normalizeCRLF: boolean): string {
+      const ch = this.input.charCodeAt(this.state.pos);
+      let out;
+      ++this.state.pos;
+      if (
+        ch === charCodes.carriageReturn &&
+        this.input.charCodeAt(this.state.pos) === charCodes.lineFeed
+      ) {
+        ++this.state.pos;
+        out = normalizeCRLF ? "\n" : "\r\n";
+      } else {
+        out = String.fromCharCode(ch);
+      }
+      ++this.state.curLine;
+      this.state.lineStart = this.state.pos;
+
+      return out;
+    }
+
+    jsxReadString(quote: number): void {
+      let out = "";
+      let chunkStart = ++this.state.pos;
+      for (;;) {
+        if (this.state.pos >= this.input.length) {
+          this.raise(this.state.start, "Unterminated string constant");
+        }
+
+        const ch = this.input.charCodeAt(this.state.pos);
+        if (ch === quote) break;
+        if (ch === charCodes.ampersand) {
+          out += this.input.slice(chunkStart, this.state.pos);
+          out += this.jsxReadEntity();
+          chunkStart = this.state.pos;
+        } else if (isNewLine(ch)) {
+          out += this.input.slice(chunkStart, this.state.pos);
+          out += this.jsxReadNewLine(false);
+          chunkStart = this.state.pos;
+        } else {
+          ++this.state.pos;
+        }
+      }
+      out += this.input.slice(chunkStart, this.state.pos++);
+      return this.finishToken(tt.string, out);
+    }
+
+    jsxReadEntity(): string {
+      let str = "";
+      let count = 0;
+      let entity;
+      let ch = this.input[this.state.pos];
+
+      const startPos = ++this.state.pos;
+      while (this.state.pos < this.input.length && count++ < 10) {
+        ch = this.input[this.state.pos++];
+        if (ch === ";") {
+          if (str[0] === "#") {
+            if (str[1] === "x") {
+              str = str.substr(2);
+              if (HEX_NUMBER.test(str)) {
+                entity = String.fromCodePoint(parseInt(str, 16));
+              }
+            } else {
+              str = str.substr(1);
+              if (DECIMAL_NUMBER.test(str)) {
+                entity = String.fromCodePoint(parseInt(str, 10));
+              }
+            }
+          } else {
+            entity = XHTMLEntities[str];
+          }
+          break;
+        }
+        str += ch;
+      }
+      if (!entity) {
+        this.state.pos = startPos;
+        return "&";
+      }
+      return entity;
+    }
+
+    // Read a JSX identifier (valid tag or attribute name).
+    //
+    // Optimized version since JSX identifiers can"t contain
+    // escape characters and so can be read as single slice.
+    // Also assumes that first character was already checked
+    // by isIdentifierStart in readToken.
+
+    jsxReadWord(): void {
+      let ch;
+      const start = this.state.pos;
+      do {
+        ch = this.input.charCodeAt(++this.state.pos);
+      } while (isIdentifierChar(ch) || ch === charCodes.dash);
+      return this.finishToken(
+        tt.jsxName,
+        this.input.slice(start, this.state.pos),
+      );
+    }
+
+    // Parse next token as JSX identifier
+
+    jsxParseIdentifier(): N.JSXIdentifier {
+      const node = this.startNode();
+      if (this.match(tt.jsxName)) {
+        node.name = this.state.value;
+      } else if (this.state.type.keyword) {
+        node.name = this.state.type.keyword;
+      } else {
+        this.unexpected();
+      }
+      this.next();
+      return this.finishNode(node, "JSXIdentifier");
+    }
+
+    // Parse namespaced identifier.
+
+    jsxParseNamespacedName(): N.JSXNamespacedName {
+      const startPos = this.state.start;
+      const startLoc = this.state.startLoc;
+      const name = this.jsxParseIdentifier();
+      if (!this.eat(tt.colon)) return name;
+
+      const node = this.startNodeAt(startPos, startLoc);
+      node.namespace = name;
+      node.name = this.jsxParseIdentifier();
+      return this.finishNode(node, "JSXNamespacedName");
+    }
+
+    // Parses element name in any form - namespaced, member
+    // or single identifier.
+
+    jsxParseElementName(): N.JSXNamespacedName | N.JSXMemberExpression {
+      const startPos = this.state.start;
+      const startLoc = this.state.startLoc;
+      let node = this.jsxParseNamespacedName();
+      while (this.eat(tt.dot)) {
+        const newNode = this.startNodeAt(startPos, startLoc);
+        newNode.object = node;
+        newNode.property = this.jsxParseIdentifier();
+        node = this.finishNode(newNode, "JSXMemberExpression");
+      }
+      return node;
+    }
+
+    // Parses any type of JSX attribute value.
+
+    jsxParseAttributeValue(): N.Expression {
+      let node;
+      switch (this.state.type) {
+        case tt.braceL:
+          node = this.jsxParseExpressionContainer();
+          if (node.expression.type === "JSXEmptyExpression") {
+            throw this.raise(
+              node.start,
+              "JSX attributes must only be assigned a non-empty expression",
+            );
+          } else {
+            return node;
+          }
+
+        case tt.jsxTagStart:
+        case tt.string:
+          return this.parseExprAtom();
+
+        default:
+          throw this.raise(
+            this.state.start,
+            "JSX value should be either an expression or a quoted JSX text",
+          );
+      }
+    }
+
+    // JSXEmptyExpression is unique type since it doesn't actually parse anything,
+    // and so it should start at the end of last read token (left brace) and finish
+    // at the beginning of the next one (right brace).
+
+    jsxParseEmptyExpression(): N.JSXEmptyExpression {
+      const node = this.startNodeAt(
+        this.state.lastTokEnd,
+        this.state.lastTokEndLoc,
+      );
+      return this.finishNodeAt(
+        node,
+        "JSXEmptyExpression",
+        this.state.start,
+        this.state.startLoc,
+      );
+    }
+
+    // Parse JSX spread child
+
+    jsxParseSpreadChild(): N.JSXSpreadChild {
+      const node = this.startNode();
+      this.expect(tt.braceL);
+      this.expect(tt.ellipsis);
+      node.expression = this.parseExpression();
+      this.expect(tt.braceR);
+
+      return this.finishNode(node, "JSXSpreadChild");
+    }
+
+    // Parses JSX expression enclosed into curly brackets.
+
+    jsxParseExpressionContainer(): N.JSXExpressionContainer {
+      const node = this.startNode();
+      this.next();
+      if (this.match(tt.braceR)) {
+        node.expression = this.jsxParseEmptyExpression();
+      } else {
+        node.expression = this.parseExpression();
+      }
+      this.expect(tt.braceR);
+      return this.finishNode(node, "JSXExpressionContainer");
+    }
+
+    // Parses following JSX attribute name-value pair.
+
+    jsxParseAttribute(): N.JSXAttribute {
+      const node = this.startNode();
+      if (this.eat(tt.braceL)) {
+        this.expect(tt.ellipsis);
+        node.argument = this.parseMaybeAssign();
+        this.expect(tt.braceR);
+        return this.finishNode(node, "JSXSpreadAttribute");
+      }
+      node.name = this.jsxParseNamespacedName();
+      node.value = this.eat(tt.eq) ? this.jsxParseAttributeValue() : null;
+      return this.finishNode(node, "JSXAttribute");
+    }
+
+    // Parses JSX opening tag starting after "<".
+
+    jsxParseOpeningElementAt(
+      startPos: number,
+      startLoc: Position,
+    ): N.JSXOpeningElement {
+      const node = this.startNodeAt(startPos, startLoc);
+      if (this.match(tt.jsxTagEnd)) {
+        this.expect(tt.jsxTagEnd);
+        return this.finishNode(node, "JSXOpeningFragment");
+      }
+      node.attributes = [];
+      node.name = this.jsxParseElementName();
+      while (!this.match(tt.slash) && !this.match(tt.jsxTagEnd)) {
+        node.attributes.push(this.jsxParseAttribute());
+      }
+      node.selfClosing = this.eat(tt.slash);
+      this.expect(tt.jsxTagEnd);
+      return this.finishNode(node, "JSXOpeningElement");
+    }
+
+    // Parses JSX closing tag starting after "</".
+
+    jsxParseClosingElementAt(
+      startPos: number,
+      startLoc: Position,
+    ): N.JSXClosingElement {
+      const node = this.startNodeAt(startPos, startLoc);
+      if (this.match(tt.jsxTagEnd)) {
+        this.expect(tt.jsxTagEnd);
+        return this.finishNode(node, "JSXClosingFragment");
+      }
+      node.name = this.jsxParseElementName();
+      this.expect(tt.jsxTagEnd);
+      return this.finishNode(node, "JSXClosingElement");
+    }
+
+    // Parses entire JSX element, including it"s opening tag
+    // (starting after "<"), attributes, contents and closing tag.
+
+    jsxParseElementAt(startPos: number, startLoc: Position): N.JSXElement {
+      const node = this.startNodeAt(startPos, startLoc);
+      const children = [];
+      const openingElement = this.jsxParseOpeningElementAt(startPos, startLoc);
+      let closingElement = null;
+
+      if (!openingElement.selfClosing) {
+        contents: for (;;) {
+          switch (this.state.type) {
+            case tt.jsxTagStart:
+              startPos = this.state.start;
+              startLoc = this.state.startLoc;
+              this.next();
+              if (this.eat(tt.slash)) {
+                closingElement = this.jsxParseClosingElementAt(
+                  startPos,
+                  startLoc,
+                );
+                break contents;
+              }
+              children.push(this.jsxParseElementAt(startPos, startLoc));
+              break;
+
+            case tt.jsxText:
+              children.push(this.parseExprAtom());
+              break;
+
+            case tt.braceL:
+              if (this.lookahead().type === tt.ellipsis) {
+                children.push(this.jsxParseSpreadChild());
+              } else {
+                children.push(this.jsxParseExpressionContainer());
+              }
+
+              break;
+
+            // istanbul ignore next - should never happen
+            default:
+              throw this.unexpected();
+          }
+        }
+
+        if (isFragment(openingElement) && !isFragment(closingElement)) {
+          this.raise(
+            // $FlowIgnore
+            closingElement.start,
+            "Expected corresponding JSX closing tag for <>",
+          );
+        } else if (!isFragment(openingElement) && isFragment(closingElement)) {
+          this.raise(
+            // $FlowIgnore
+            closingElement.start,
+            "Expected corresponding JSX closing tag for <" +
+              getQualifiedJSXName(openingElement.name) +
+              ">",
+          );
+        } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
+          if (
+            // $FlowIgnore
+            getQualifiedJSXName(closingElement.name) !==
+            getQualifiedJSXName(openingElement.name)
+          ) {
+            this.raise(
+              // $FlowIgnore
+              closingElement.start,
+              "Expected corresponding JSX closing tag for <" +
+                getQualifiedJSXName(openingElement.name) +
+                ">",
+            );
+          }
+        }
+      }
+
+      if (isFragment(openingElement)) {
+        node.openingFragment = openingElement;
+        node.closingFragment = closingElement;
+      } else {
+        node.openingElement = openingElement;
+        node.closingElement = closingElement;
+      }
+      node.children = children;
+      if (this.match(tt.relational) && this.state.value === "<") {
+        this.raise(
+          this.state.start,
+          "Adjacent JSX elements must be wrapped in an enclosing tag. " +
+            "Did you want a JSX fragment <>...</>?",
+        );
+      }
+
+      return isFragment(openingElement)
+        ? this.finishNode(node, "JSXFragment")
+        : this.finishNode(node, "JSXElement");
+    }
+
+    // Parses entire JSX element from current position.
+
+    jsxParseElement(): N.JSXElement {
+      const startPos = this.state.start;
+      const startLoc = this.state.startLoc;
+      this.next();
+      return this.jsxParseElementAt(startPos, startLoc);
+    }
+
+    // ==================================
+    // Overrides
+    // ==================================
+
+    parseExprAtom(refShortHandDefaultPos: ?Pos): N.Expression {
+      if (this.match(tt.jsxText)) {
+        return this.parseLiteral(this.state.value, "JSXText");
+      } else if (this.match(tt.jsxTagStart)) {
+        return this.jsxParseElement();
+      } else {
+        return super.parseExprAtom(refShortHandDefaultPos);
+      }
+    }
+
+    readToken(code: number): void {
+      if (this.state.inPropertyName) return super.readToken(code);
+
+      const context = this.curContext();
+
+      if (context === tc.j_expr) {
+        return this.jsxReadToken();
+      }
+
+      if (context === tc.j_oTag || context === tc.j_cTag) {
+        if (isIdentifierStart(code)) {
+          return this.jsxReadWord();
+        }
+
+        if (code === charCodes.greaterThan) {
+          ++this.state.pos;
+          return this.finishToken(tt.jsxTagEnd);
+        }
+
+        if (
+          (code === charCodes.quotationMark || code === charCodes.apostrophe) &&
+          context === tc.j_oTag
+        ) {
+          return this.jsxReadString(code);
+        }
+      }
+
+      if (code === charCodes.lessThan && this.state.exprAllowed) {
+        ++this.state.pos;
+        return this.finishToken(tt.jsxTagStart);
+      }
+
+      return super.readToken(code);
+    }
+
+    updateContext(prevType: TokenType): void {
+      if (this.match(tt.braceL)) {
+        const curContext = this.curContext();
+        if (curContext === tc.j_oTag) {
+          this.state.context.push(tc.braceExpression);
+        } else if (curContext === tc.j_expr) {
+          this.state.context.push(tc.templateQuasi);
+        } else {
+          super.updateContext(prevType);
+        }
+        this.state.exprAllowed = true;
+      } else if (this.match(tt.slash) && prevType === tt.jsxTagStart) {
+        this.state.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
+        this.state.context.push(tc.j_cTag); // reconsider as closing tag context
+        this.state.exprAllowed = false;
+      } else {
+        return super.updateContext(prevType);
+      }
+    }
+  };

packages/babel-parser/src/plugins/jsx/xhtml.js

@@ -0,0 +1,258 @@
+// @flow
+
+const entities: { [name: string]: string } = {
+  quot: "\u0022",
+  amp: "&",
+  apos: "\u0027",
+  lt: "<",
+  gt: ">",
+  nbsp: "\u00A0",
+  iexcl: "\u00A1",
+  cent: "\u00A2",
+  pound: "\u00A3",
+  curren: "\u00A4",
+  yen: "\u00A5",
+  brvbar: "\u00A6",
+  sect: "\u00A7",
+  uml: "\u00A8",
+  copy: "\u00A9",
+  ordf: "\u00AA",
+  laquo: "\u00AB",
+  not: "\u00AC",
+  shy: "\u00AD",
+  reg: "\u00AE",
+  macr: "\u00AF",
+  deg: "\u00B0",
+  plusmn: "\u00B1",
+  sup2: "\u00B2",
+  sup3: "\u00B3",
+  acute: "\u00B4",
+  micro: "\u00B5",
+  para: "\u00B6",
+  middot: "\u00B7",
+  cedil: "\u00B8",
+  sup1: "\u00B9",
+  ordm: "\u00BA",
+  raquo: "\u00BB",
+  frac14: "\u00BC",
+  frac12: "\u00BD",
+  frac34: "\u00BE",
+  iquest: "\u00BF",
+  Agrave: "\u00C0",
+  Aacute: "\u00C1",
+  Acirc: "\u00C2",
+  Atilde: "\u00C3",
+  Auml: "\u00C4",
+  Aring: "\u00C5",
+  AElig: "\u00C6",
+  Ccedil: "\u00C7",
+  Egrave: "\u00C8",
+  Eacute: "\u00C9",
+  Ecirc: "\u00CA",
+  Euml: "\u00CB",
+  Igrave: "\u00CC",
+  Iacute: "\u00CD",
+  Icirc: "\u00CE",
+  Iuml: "\u00CF",
+  ETH: "\u00D0",
+  Ntilde: "\u00D1",
+  Ograve: "\u00D2",
+  Oacute: "\u00D3",
+  Ocirc: "\u00D4",
+  Otilde: "\u00D5",
+  Ouml: "\u00D6",
+  times: "\u00D7",
+  Oslash: "\u00D8",
+  Ugrave: "\u00D9",
+  Uacute: "\u00DA",
+  Ucirc: "\u00DB",
+  Uuml: "\u00DC",
+  Yacute: "\u00DD",
+  THORN: "\u00DE",
+  szlig: "\u00DF",
+  agrave: "\u00E0",
+  aacute: "\u00E1",
+  acirc: "\u00E2",
+  atilde: "\u00E3",
+  auml: "\u00E4",
+  aring: "\u00E5",
+  aelig: "\u00E6",
+  ccedil: "\u00E7",
+  egrave: "\u00E8",
+  eacute: "\u00E9",
+  ecirc: "\u00EA",
+  euml: "\u00EB",
+  igrave: "\u00EC",
+  iacute: "\u00ED",
+  icirc: "\u00EE",
+  iuml: "\u00EF",
+  eth: "\u00F0",
+  ntilde: "\u00F1",
+  ograve: "\u00F2",
+  oacute: "\u00F3",
+  ocirc: "\u00F4",
+  otilde: "\u00F5",
+  ouml: "\u00F6",
+  divide: "\u00F7",
+  oslash: "\u00F8",
+  ugrave: "\u00F9",
+  uacute: "\u00FA",
+  ucirc: "\u00FB",
+  uuml: "\u00FC",
+  yacute: "\u00FD",
+  thorn: "\u00FE",
+  yuml: "\u00FF",
+  OElig: "\u0152",
+  oelig: "\u0153",
+  Scaron: "\u0160",
+  scaron: "\u0161",
+  Yuml: "\u0178",
+  fnof: "\u0192",
+  circ: "\u02C6",
+  tilde: "\u02DC",
+  Alpha: "\u0391",
+  Beta: "\u0392",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Epsilon: "\u0395",
+  Zeta: "\u0396",
+  Eta: "\u0397",
+  Theta: "\u0398",
+  Iota: "\u0399",
+  Kappa: "\u039A",
+  Lambda: "\u039B",
+  Mu: "\u039C",
+  Nu: "\u039D",
+  Xi: "\u039E",
+  Omicron: "\u039F",
+  Pi: "\u03A0",
+  Rho: "\u03A1",
+  Sigma: "\u03A3",
+  Tau: "\u03A4",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Chi: "\u03A7",
+  Psi: "\u03A8",
+  Omega: "\u03A9",
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  omicron: "\u03BF",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigmaf: "\u03C2",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  thetasym: "\u03D1",
+  upsih: "\u03D2",
+  piv: "\u03D6",
+  ensp: "\u2002",
+  emsp: "\u2003",
+  thinsp: "\u2009",
+  zwnj: "\u200C",
+  zwj: "\u200D",
+  lrm: "\u200E",
+  rlm: "\u200F",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bdquo: "\u201E",
+  dagger: "\u2020",
+  Dagger: "\u2021",
+  bull: "\u2022",
+  hellip: "\u2026",
+  permil: "\u2030",
+  prime: "\u2032",
+  Prime: "\u2033",
+  lsaquo: "\u2039",
+  rsaquo: "\u203A",
+  oline: "\u203E",
+  frasl: "\u2044",
+  euro: "\u20AC",
+  image: "\u2111",
+  weierp: "\u2118",
+  real: "\u211C",
+  trade: "\u2122",
+  alefsym: "\u2135",
+  larr: "\u2190",
+  uarr: "\u2191",
+  rarr: "\u2192",
+  darr: "\u2193",
+  harr: "\u2194",
+  crarr: "\u21B5",
+  lArr: "\u21D0",
+  uArr: "\u21D1",
+  rArr: "\u21D2",
+  dArr: "\u21D3",
+  hArr: "\u21D4",
+  forall: "\u2200",
+  part: "\u2202",
+  exist: "\u2203",
+  empty: "\u2205",
+  nabla: "\u2207",
+  isin: "\u2208",
+  notin: "\u2209",
+  ni: "\u220B",
+  prod: "\u220F",
+  sum: "\u2211",
+  minus: "\u2212",
+  lowast: "\u2217",
+  radic: "\u221A",
+  prop: "\u221D",
+  infin: "\u221E",
+  ang: "\u2220",
+  and: "\u2227",
+  or: "\u2228",
+  cap: "\u2229",
+  cup: "\u222A",
+  int: "\u222B",
+  there4: "\u2234",
+  sim: "\u223C",
+  cong: "\u2245",
+  asymp: "\u2248",
+  ne: "\u2260",
+  equiv: "\u2261",
+  le: "\u2264",
+  ge: "\u2265",
+  sub: "\u2282",
+  sup: "\u2283",
+  nsub: "\u2284",
+  sube: "\u2286",
+  supe: "\u2287",
+  oplus: "\u2295",
+  otimes: "\u2297",
+  perp: "\u22A5",
+  sdot: "\u22C5",
+  lceil: "\u2308",
+  rceil: "\u2309",
+  lfloor: "\u230A",
+  rfloor: "\u230B",
+  lang: "\u2329",
+  rang: "\u232A",
+  loz: "\u25CA",
+  spades: "\u2660",
+  clubs: "\u2663",
+  hearts: "\u2665",
+  diams: "\u2666",
+};
+export default entities;