Modify grammar to support Private Fields proposal:

ast/spec.md

@@ -3,6 +3,7 @@ These are the core Babylon AST node types.
 - [Node objects](#node-objects)
 - [Changes](#changes)
 - [Identifier](#identifier)
+- [PrivateName](#privatename)
 - [Literals](#literals)
   - [RegExpLiteral](#regexpliteral)
   - [NullLiteral](#nullliteral)
@@ -90,6 +91,7 @@ These are the core Babylon AST node types.
   - [ClassBody](#classbody)
   - [ClassMethod](#classmethod)
   - [ClassProperty](#classproperty)
+  - [ClassPrivateProperty](#classprivateproperty)
   - [ClassDeclaration](#classdeclaration)
   - [ClassExpression](#classexpression)
   - [MetaProperty](#metaproperty)
@@ -166,6 +168,18 @@ interface Identifier <: Expression, Pattern {
 
 An identifier. Note that an identifier may be an expression or a destructuring pattern.
 
+
+# PrivateName
+
+```js
+interface PrivateName <: Expression, Pattern {
+  type: "PrivateName";
+  name: Identifier;
+}
+```
+A Private Name Identifier.
+
+
 # Literals
 
 ```js
@@ -1015,7 +1029,7 @@ interface Class <: Node {
 ```js
 interface ClassBody <: Node {
   type: "ClassBody";
-  body: [ ClassMethod | ClassProperty ];
+  body: [ ClassMethod | ClassProperty | ClassPrivateProperty ];
 }
 ```
 
@@ -1043,6 +1057,16 @@ interface ClassProperty <: Node {
 }
 ```
 
+## ClassPrivateProperty
+
+```js
+interface ClassPrivateProperty <: Node {
+  type: "ClassPrivateProperty";
+  key: Identifier;
+  value: Expression;
+}
+```
+
 ## ClassDeclaration
 
 ```js

src/parser/expression.js

@@ -99,7 +99,6 @@ export default class ExpressionParser extends LValParser {
   parseMaybeAssign(noIn?: ?boolean, refShorthandDefaultPos?: ?Pos, afterLeftParse?: Function, refNeedsArrowPos?: ?Pos): N.Expression {
     const startPos = this.state.start;
     const startLoc = this.state.startLoc;
-
     if (this.match(tt._yield) && this.state.inGenerator) {
       let left = this.parseYield();
       if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc);
@@ -297,7 +296,7 @@ export default class ExpressionParser extends LValParser {
       } else if (this.eat(tt.dot)) {
         const node = this.startNodeAt(startPos, startLoc);
         node.object = base;
-        node.property = this.parseIdentifier(true);
+        node.property = this.hasPlugin("classPrivateProperties") ? this.parseMaybePrivateName() : this.parseIdentifier(true);
         node.computed = false;
         base = this.finishNode(node, "MemberExpression");
       } else if (this.eat(tt.bracketL)) {
@@ -518,6 +517,13 @@ export default class ExpressionParser extends LValParser {
         this.takeDecorators(node);
         return this.parseClass(node, false);
 
+      case tt.hash:
+        if (this.hasPlugin("classPrivateProperties")) {
+          return this.parseMaybePrivateName();
+        } else {
+          this.unexpected();
+        }
+
       case tt._new:
         return this.parseNew();
 
@@ -540,6 +546,18 @@ export default class ExpressionParser extends LValParser {
     }
   }
 
+  parseMaybePrivateName(): N.PrivateName | N.Identifier {
+    const isPrivate = this.eat(tt.hash);
+
+    if (isPrivate) {
+      const node = this.startNode();
+      node.name = this.parseIdentifier(true);
+      return this.finishNode(node, "PrivateName");
+    } else {
+      return this.parseIdentifier(true);
+    }
+  }
+
   parseFunctionExpression(): N.FunctionExpression | N.MetaProperty {
     const node = this.startNode();
     const meta = this.parseIdentifier(true);

src/parser/lval.js

@@ -26,6 +26,7 @@ export default class LValParser extends NodeUtils {
     if (node) {
       switch (node.type) {
         case "Identifier":
+        case "PrivateName":
         case "ObjectPattern":
         case "ArrayPattern":
         case "AssignmentPattern":
@@ -227,6 +228,7 @@ export default class LValParser extends NodeUtils {
     checkClashes: ?{ [key: string]: boolean },
     contextDescription: string): void {
     switch (expr.type) {
+      case "PrivateName":
       case "Identifier":
         this.checkReservedWord(expr.name, expr.start, false, true);
 

src/parser/statement.js

@@ -650,6 +650,7 @@ export default class StatementParser extends ExpressionParser {
     // class bodies are implicitly strict
     const oldStrict = this.state.strict;
     this.state.strict = true;
+    this.state.inClass = true;
 
     let hadConstructor = false;
     let decorators = [];
@@ -680,6 +681,13 @@ export default class StatementParser extends ExpressionParser {
         decorators = [];
       }
 
+      if (this.hasPlugin("classPrivateProperties") && this.match(tt.hash)) { // Private property
+        this.next();
+        this.parsePropertyName(method);
+        classBody.body.push(this.parsePrivateClassProperty(method));
+        continue;
+      }
+
       method.static = false;
       if (this.match(tt.name) && this.state.value === "static") {
         const key = this.parseIdentifier(true); // eats 'static'
@@ -774,9 +782,26 @@ export default class StatementParser extends ExpressionParser {
 
     node.body = this.finishNode(classBody, "ClassBody");
 
+    this.state.inClass = false;
     this.state.strict = oldStrict;
+
   }
 
+  parsePrivateClassProperty(node: N.ClassPrivateProperty): N.ClassPrivateProperty {
+    this.state.inClassProperty = true;
+
+    if (this.match(tt.eq)) {
+      this.next();
+      node.value = this.parseMaybeAssign();
+    } else {
+      node.value = null;
+    }
+    this.semicolon();
+    this.state.inClassProperty = false;
+    return this.finishNode(node, "ClassPrivateProperty");
+  }
+
+
   parseClassProperty(node: N.ClassProperty): N.ClassProperty {
     const hasPlugin = this.hasPlugin("classProperties");
     const noPluginMsg = "You can only use Class Properties when the 'classProperties' plugin is enabled.";

src/tokenizer/index.js

@@ -405,8 +405,17 @@ export default class Tokenizer extends LocationParser {
 
   getTokenFromCode(code: number): void {
     switch (code) {
+
+      case 35: // '#'
+        if (this.hasPlugin("classPrivateProperties") && this.state.inClass) {
+          ++this.state.pos; return this.finishToken(tt.hash);
+        } else {
+          this.raise(this.state.pos, `Unexpected character '${codePointToString(code)}'`);
+        }
+
       // The interpretation of a dot depends on whether it is followed
       // by a digit or another two dots.
+
       case 46: // '.'
         return this.readToken_dot();
 

src/tokenizer/state.js

@@ -24,6 +24,7 @@ export default class State {
       this.inAsync =
       this.inPropertyName =
       this.inType =
+      this.inClass =
       this.inClassProperty =
       this.noAnonFunctionType =
         false;
@@ -81,6 +82,7 @@ export default class State {
   noAnonFunctionType: boolean;
   inPropertyName: boolean;
   inClassProperty: boolean;
+  inClass: boolean;
 
   // Labels in scope.
   labels: Array<{ kind: ?("loop" | "switch"), statementStart?: number }>;

src/tokenizer/types.js

@@ -108,6 +108,7 @@ export const types: { [name: string]: TokenType } = {
   backQuote: new TokenType("`", { startsExpr }),
   dollarBraceL: new TokenType("${", { beforeExpr, startsExpr }),
   at: new TokenType("@"),
+  hash: new TokenType("#"),
 
   // Operators. These carry several kinds of properties to help the
   // parser use them properly (the presence of these properties is

src/types.js

@@ -62,6 +62,13 @@ export type Identifier = PatternBase & {
   __clone(): Identifier;
 };
 
+export type PrivateName = PatternBase & {
+  type: "PrivateName";
+  name: string;
+
+  __clone(): Identifier;
+};
+
 // Literals
 
 export type Literal = RegExpLiteral | NullLiteral | StringLiteral | BooleanLiteral | NumericLiteral;
@@ -334,7 +341,7 @@ export type ObjectExpression = NodeBase & {
   properties: $ReadOnlyArray<ObjectProperty | ObjectMethod | SpreadElement>;
 };
 
-export type ObjectOrClassMember = ClassMethod | ClassProperty | ObjectMember;
+export type ObjectOrClassMember = ClassMethod | ClassProperty | ClassPrivateProperty | ObjectMember;
 
 export type ObjectMember = ObjectProperty | ObjectMethod;
 
@@ -552,7 +559,7 @@ export type ClassMemberBase = NodeBase & HasDecorators & {
 
 export type Accessibility = "public" | "protected" | "private";
 
-export type ClassMember = ClassMethod | ClassProperty;
+export type ClassMember = ClassMethod | ClassProperty | ClassPrivateProperty;
 
 export type MethodLike = ObjectMethod | FunctionExpression | ClassMethod;
 
@@ -584,6 +591,18 @@ export type ClassProperty = ClassMemberBase & {
   readonly?: true;
 };
 
+export type ClassPrivateProperty = ClassMemberBase & {
+  type: "ClassPrivateProperty";
+  key: Identifier;
+  value: ?Expression; // TODO: Not in spec that this is nullable.
+
+  typeAnnotation?: ?FlowTypeAnnotation; // TODO: Not in spec
+  variance?: ?FlowVariance; // TODO: Not in spec
+
+  // TypeScript only: (TODO: Not in spec)
+  readonly?: true;
+};
+
 export type OptClassDeclaration = ClassBase & DeclarationBase & HasDecorators & {
   type: "ClassDeclaration";
   // TypeScript only

test/fixtures/experimental/class-private-properties/asi-failure-computed/actual.js

@@ -0,0 +1,4 @@
+class Foo {
+  #p = x
+  [#m] () {}
+}

test/fixtures/experimental/class-private-properties/asi-failure-computed/options.json

@@ -0,0 +1,7 @@
+{
+  "throws": "Unexpected token, expected ; (3:10)",
+  "plugins": [
+    "classProperties",
+    "classPrivateProperties"
+    ]
+}

test/fixtures/experimental/class-private-properties/asi-failure-generator/actual.js

@@ -0,0 +1,4 @@
+class Foo {
+  #p = x
+  *#m () {}
+}

test/fixtures/experimental/class-private-properties/asi-failure-generator/options.json

@@ -0,0 +1,4 @@
+{
+  "throws": "Unexpected token, expected ; (3:9)",
+  "plugins": ["classProperties", "classPrivateProperties"]
+}

test/fixtures/experimental/class-private-properties/asi-failure-inline/actual.js

@@ -0,0 +1,3 @@
+class Foo {
+  #x #y
+}

test/fixtures/experimental/class-private-properties/asi-failure-inline/options.json

@@ -0,0 +1,4 @@
+{
+  "throws": "Unexpected token, expected ; (2:5)",
+  "plugins": ["classProperties", "classPrivateProperties"]
+}

test/fixtures/experimental/class-private-properties/asi-success/actual.js

@@ -0,0 +1,4 @@
+class Foo {
+  #x
+  #y
+}