Merge pull request #11 from browserify/acorn-7

Update acorn to v7

Author: goto-bus-stop

README.md

@@ -29,12 +29,13 @@ var acorn = require('acorn-node')
 
 The API is the same as [acorn](https://github.com/acornjs/acorn), but the following syntax features are enabled by default:
 
- - Bigint syntax (via [acorn-bigint](https://github.com/acornjs/acorn-bigint]), MIT)
- - Public and private class instance fields (via [acorn-class-fields](https://github.com/acornjs/acorn-class-fields), MIT)
- - Public and private class static fields (via [acorn-static-class-features](https://github.com/acornjs/acorn-static-class-features), MIT)
- - Dynamic `import()` (via [acorn-dynamic-import](https://github.com/kesne/acorn-dynamic-import))
- - The `import.meta` property (via [acorn-import-meta](https://github.com/acornjs/acorn-import-meta), MIT)
- - `export * as ns from` syntax (via [acorn-export-ns-from](https://github.com/acornjs/acorn-export-ns-from), MIT)
+ - Bigint syntax `10n`
+ - Numeric separators syntax `10_000`
+ - Public and private class instance fields
+ - Public and private class static fields
+ - Dynamic `import()`
+ - The `import.meta` property
+ - `export * as ns from` syntax
 
 And the following options have different defaults from acorn, to match Node modules:
 
@@ -51,4 +52,14 @@ See the [acorn documentation](https://github.com/acornjs/acorn#distwalkjs) for d
 
 ## License
 
-[Apache-2.0](LICENSE.md)
+The files in the repo root and the ./test folder are licensed as [Apache-2.0](LICENSE.md).
+
+The files in lib/ are generated from other packages:
+
+- lib/bigint: [acorn-bigint](https://github.com/acornjs/acorn-bigint]), MIT
+- lib/class-private-elements: [acorn-class-private-elements](https://github.com/acornjs/acorn-class-private-elements), MIT
+- lib/dynamic-import: [acorn-dynamic-import](https://github.com/acornjs/acorn-dynamic-import), MIT
+- lib/export-ns-from: [acorn-export-ns-from](https://github.com/acornjs/acorn-export-ns-from), MIT
+- lib/import-meta: [acorn-import-meta](https://github.com/acornjs/acorn-import-meta), MIT
+- lib/numeric-separator: [acorn-numeric-separator](https://github.com/acornjs/acorn-numeric-separator]), MIT
+- lib/static-class-features: [acorn-static-class-features](https://github.com/acornjs/acorn-static-class-features), MIT

build.js

@@ -23,6 +23,8 @@ function privateClassElements (str) {
 }
 
 compile('acorn-bigint', './lib/bigint/index.js')
+compile('acorn-numeric-separator', './lib/numeric-separator/index.js')
+compile('acorn-dynamic-import', './lib/dynamic-import/index.js')
 compile('acorn-import-meta', './lib/import-meta/index.js')
 compile('acorn-export-ns-from', './lib/export-ns-from/index.js')
 compile('acorn-class-fields', './lib/class-fields/index.js', privateClassElements)

index.js

@@ -5,15 +5,16 @@ var CJSParser = acorn.Parser
   .extend(require('./lib/bigint'))
   .extend(require('./lib/class-fields'))
   .extend(require('./lib/static-class-features'))
-  .extend(require('acorn-dynamic-import').default)
+  .extend(require('./lib/numeric-separator'))
+  .extend(require('./lib/dynamic-import').default)
 var ESModulesParser = CJSParser
   .extend(require('./lib/export-ns-from'))
   .extend(require('./lib/import-meta'))
 
 function mapOptions (opts) {
   if (!opts) opts = {}
   return xtend({
-    ecmaVersion: 2019,
+    ecmaVersion: 2020,
     allowHashBang: true,
     allowReturnOutsideFunction: true
   }, opts)

lib/acorn-private-class-elements/index.js

@@ -18,7 +18,7 @@ module.exports = function(Parser) {
 
     anonymous.prototype.parseLiteral = function parseLiteral (value) {
       var node = Parser.prototype.parseLiteral.call(this, value)
-      if (node.raw.charCodeAt(node.raw.length - 1) == 110) { node.bigint = node.raw }
+      if (node.raw.charCodeAt(node.raw.length - 1) == 110) { node.bigint = this.getNumberInput(node.start, node.end) }
       return node
     };
 
@@ -28,7 +28,7 @@ module.exports = function(Parser) {
       var val = this.readInt(radix)
       if (val === null) { this.raise(this.start + 2, ("Expected number in radix " + radix)) }
       if (this.input.charCodeAt(this.pos) == 110) {
-        var str = this.input.slice(start, this.pos)
+        var str = this.getNumberInput(start, this.pos)
         val = typeof BigInt !== "undefined" ? BigInt(str) : null
         ++this.pos
       } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number") }
@@ -54,12 +54,18 @@ module.exports = function(Parser) {
         return Parser.prototype.readNumber.call(this, startsWithDot)
       }
 
-      var str = this.input.slice(start, this.pos)
+      var str = this.getNumberInput(start, this.pos)
       var val = typeof BigInt !== "undefined" ? BigInt(str) : null
       ++this.pos
       return this.finishToken(tt.num, val)
     };
 
+    // This is basically a hook for acorn-numeric-separator
+    anonymous.prototype.getNumberInput = function getNumberInput (start, end) {
+      if (Parser.prototype.getNumberInput) { return Parser.prototype.getNumberInput.call(this, start, end) }
+      return this.input.slice(start, end)
+    };
+
     return anonymous;
   }(Parser))
 }

lib/bigint/index.js

@@ -0,0 +1,86 @@
+/* Generated by `npm run build`, do not edit! */
+
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DynamicImportKey = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) { descriptor.writable = true; } Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) { defineProperties(Constructor.prototype, protoProps); } if (staticProps) { defineProperties(Constructor, staticProps); } return Constructor; }; }();
+
+var _get = function () {
+  function get(object, property, receiver) { if (object === null) { object = Function.prototype; } var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+
+  return get;
+}();
+
+exports['default'] = dynamicImport;
+
+var _acorn = require('acorn');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) { Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } } /* eslint-disable no-underscore-dangle */
+
+
+var DynamicImportKey = exports.DynamicImportKey = 'Import';
+
+// NOTE: This allows `yield import()` to parse correctly.
+_acorn.tokTypes._import.startsExpr = true;
+
+function parseDynamicImport() {
+  var node = this.startNode();
+  this.next();
+  if (this.type !== _acorn.tokTypes.parenL) {
+    this.unexpected();
+  }
+  return this.finishNode(node, DynamicImportKey);
+}
+
+function parenAfter() {
+  return (/^(\s|\/\/.*|\/\*[^]*?\*\/)*\(/.test(this.input.slice(this.pos))
+  );
+}
+
+function dynamicImport(Parser) {
+  return function (_Parser) {
+    _inherits(_class, _Parser);
+
+    function _class() {
+      _classCallCheck(this, _class);
+
+      return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));
+    }
+
+    _createClass(_class, [{
+      key: 'parseStatement',
+      value: function () {
+        function parseStatement(context, topLevel, exports) {
+          if (this.type === _acorn.tokTypes._import && parenAfter.call(this)) {
+            return this.parseExpressionStatement(this.startNode(), this.parseExpression());
+          }
+          return _get(_class.prototype.__proto__ || Object.getPrototypeOf(_class.prototype), 'parseStatement', this).call(this, context, topLevel, exports);
+        }
+
+        return parseStatement;
+      }()
+    }, {
+      key: 'parseExprAtom',
+      value: function () {
+        function parseExprAtom(refDestructuringErrors) {
+          if (this.type === _acorn.tokTypes._import) {
+            return parseDynamicImport.call(this);
+          }
+          return _get(_class.prototype.__proto__ || Object.getPrototypeOf(_class.prototype), 'parseExprAtom', this).call(this, refDestructuringErrors);
+        }
+
+        return parseExprAtom;
+      }()
+    }]);
+
+    return _class;
+  }(Parser);
+}

lib/dynamic-import/index.js

@@ -37,6 +37,9 @@ module.exports = function(Parser) {
       if (node.property.name !== "meta") {
         this.raiseRecoverable(node.property.start, "The only valid meta property for import is import.meta")
       }
+      if (this.containsEsc) {
+        this.raiseRecoverable(node.property.start, "\"meta\" in import.meta must not contain escape sequences")
+      }
       return this.finishNode(node, "MetaProperty")
     };
 

lib/import-meta/index.js

@@ -0,0 +1,61 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+module.exports = function(Parser) {
+  return /*@__PURE__*/(function (Parser) {
+    function anonymous () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) anonymous.__proto__ = Parser;
+    anonymous.prototype = Object.create( Parser && Parser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.readInt = function readInt (radix, len) {
+      // Hack: len is only != null for unicode escape sequences,
+      // where numeric separators are not allowed
+      if (len != null) { return Parser.prototype.readInt.call(this, radix, len) }
+
+      var start = this.pos, total = 0, acceptUnderscore = false
+      for (;;) {
+        var code = this.input.charCodeAt(this.pos), val = (void 0)
+        if (code >= 97) { val = code - 97 + 10 } // a
+        else if (code == 95) {
+          if (!acceptUnderscore) { this.raise(this.pos, "Invalid numeric separator") }
+          ++this.pos
+          acceptUnderscore = false
+          continue
+        } else if (code >= 65) { val = code - 65 + 10 } // A
+        else if (code >= 48 && code <= 57) { val = code - 48 } // 0-9
+        else { val = Infinity }
+        if (val >= radix) { break }
+        ++this.pos
+        total = total * radix + val
+        acceptUnderscore = true
+      }
+      if (this.pos === start) { return null }
+      if (!acceptUnderscore) { this.raise(this.pos - 1, "Invalid numeric separator") }
+
+      return total
+    };
+
+    anonymous.prototype.readNumber = function readNumber (startsWithDot) {
+      var token = Parser.prototype.readNumber.call(this, startsWithDot)
+      var octal = this.end - this.start >= 2 && this.input.charCodeAt(this.start) === 48
+      var stripped = this.getNumberInput(this.start, this.end)
+      if (stripped.length < this.end - this.start) {
+        if (octal) { this.raise(this.start, "Invalid number") }
+        this.value = parseFloat(stripped)
+      }
+      return token
+    };
+
+    // This is used by acorn-bigint
+    anonymous.prototype.getNumberInput = function getNumberInput (start, end) {
+      return this.input.slice(start, end).replace(/_/g, "")
+    };
+
+    return anonymous;
+  }(Parser))
+}