deps/acorn-plugins/acorn-class-fields/index.js


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

"use strict"

const acorn = require('internal/deps/acorn/acorn/dist/acorn')
const tt = acorn.tokTypes
const privateClassElements = require('internal/deps/acorn-plugins/acorn-private-class-elements/index')

function maybeParseFieldValue(field) {
  if (this.eat(tt.eq)) {
    const oldInFieldValue = this._inFieldValue
    this._inFieldValue = true
    field.value = this.parseExpression()
    this._inFieldValue = oldInFieldValue
  } else field.value = null
}

module.exports = function(Parser) {
  Parser = privateClassElements(Parser)
  return class extends Parser {
    // Parse fields
    parseClassElement(_constructorAllowsSuper) {
      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type == this.privateNameToken || this.type == tt.bracketL || this.type == tt.string)) {
        const branch = this._branch()
        if (branch.type == tt.bracketL) {
          let count = 0
          do {
            if (branch.eat(tt.bracketL)) ++count
            else if (branch.eat(tt.bracketR)) --count
            else branch.next()
          } while (count > 0)
        } else branch.next()
        if (branch.type == tt.eq || branch.canInsertSemicolon() || branch.type == tt.semi) {
          const node = this.startNode()
          if (this.type == this.privateNameToken) {
            this.parsePrivateClassElementName(node)
          } else {
            this.parsePropertyName(node)
          }
          if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
              (node.key.type === "Literal" && node.key.value === "constructor")) {
            this.raise(node.key.start, "Classes may not have a field called constructor")
          }
          maybeParseFieldValue.call(this, node)
          this.finishNode(node, "FieldDefinition")
          this.semicolon()
          return node
        }
      }

      return super.parseClassElement.apply(this, arguments)
    }

    // Prohibit arguments in class field initializers
    parseIdent(liberal, isBinding) {
      const ident = super.parseIdent(liberal, isBinding)
      if (this._inFieldValue && ident.name == "arguments") this.raise(ident.start, "A class field initializer may not contain arguments")
      return ident
    }
  }
}