diff --git a/README.md b/README.md
index 25edcd9a74..876a5b01ff 100644
--- a/README.md
+++ b/README.md
@@ -6,10 +6,68 @@
Babylon is a JavaScript parser used in Babel.
+ - ES6 enabled by default.
+ - Comment attachment.
+ - Support for JSX and Flow.
+ - Support for experimental language proposals.
+
## Credits
Heavily based on [acorn](https://github.com/marijnh/acorn) and [acorn-jsx](https://github.com/RReverser/acorn-jsx),
thanks to the awesome work of [@RReverser](https://github.com/RReverser) and [@marijnh](https://github.com/marijnh).
-Significant diversions are expected to occur in the future such as streaming, EBNF definitions, sweet.js integration,
-interspacial parsing, comment attachment and more.
+Significant diversions are expected to occur in the future such as streaming, EBNF definitions, sweet.js integration, interspacial parsing and more.
+
+## API
+
+### `babylon.parse(code, [options])`
+
+## Options
+
+- **allowImportExportEverywhere**: By default, `import` and `export`
+ declarations can only appear at a program's top level. Setting this
+ option to `true` allows them anywhere where a statement is allowed.
+
+- **allowReturnOutsideFunction**: By default, a return statement at
+ the top level raises an error. Set this to `true` to accept such
+ code.
+
+- **allowSuperOutsideMethod** TODO
+
+- **sourceType**: Indicate the mode the code should be parsed in. Can be
+ either `"script"` or `"module"`.
+
+- **plugins**: Array containing the plugins that you want to enable.
+
+### Example
+
+```javascript
+require("babylon").parse("code", {
+ // parse in strict mode and allow module declarations
+ sourceType: "module",
+
+ features: [
+ // enable experimental async functions
+ "asyncFunctions",
+
+ // enable jsx and flow syntax
+ "jsx",
+ "flow"
+ ]
+});
+```
+
+### Plugins
+
+ - `jsx`
+ - `flow`
+ - `asyncFunctions`
+ - `classConstructorCall`
+ - `doExpressions`
+ - `trailingFunctionCommas`
+ - `objectRestSpread`
+ - `decorators`
+ - `classProperties`
+ - `exportExtensions`
+ - `exponentiationOperator`
+ - `asyncGenerators`
diff --git a/bin/babylon.js b/bin/babylon.js
new file mode 100755
index 0000000000..ddda000631
--- /dev/null
+++ b/bin/babylon.js
@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+var babylon = require("../lib/index");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+ console.error("no filename specified");
+ process.exit(0);
+}
+
+var file = fs.readFileSync(filename, "utf8");
+var ast = babylon.parse(file);
+
+console.log(JSON.stringify(ast, null, " "));
diff --git a/package.json b/package.json
index bf1543b1a4..da4a2899a2 100644
--- a/package.json
+++ b/package.json
@@ -1,10 +1,16 @@
{
"name": "babylon",
- "version": "5.8.29",
- "description": "",
+ "version": "6.0.2",
+ "description": "A JavaScript parser",
"author": "Sebastian McKenzie ",
"homepage": "https://babeljs.io/",
"license": "MIT",
"repository": "babel/babel",
- "main": "lib/index.js"
+ "main": "lib/index.js",
+ "dependencies": {
+ "babel-runtime": "^6.0.2"
+ },
+ "bin": {
+ "babylon": "./bin/babylon.js"
+ }
}
\ No newline at end of file
diff --git a/src/index.js b/src/index.js
index 694c4e4838..b01a0b1197 100755
--- a/src/index.js
+++ b/src/index.js
@@ -1,3 +1,5 @@
+/* @flow */
+
import Parser, { plugins } from "./parser";
import "./parser/util";
import "./parser/statement";
diff --git a/src/options.js b/src/options.js
index 5c5d6d50f1..7beddde5ad 100755
--- a/src/options.js
+++ b/src/options.js
@@ -1,29 +1,28 @@
+/* @flow */
+
// A second optional argument can be given to further configure
// the parser process. These options are recognized:
export const defaultOptions = {
// Source type ("script" or "module") for different semantics
sourceType: "script",
- // By default, reserved words are not enforced. Disable
- // `allowReserved` to enforce them. When this option has the
- // value "never", reserved words and keywords can also not be
- // used as property names.
- allowReserved: true,
// When enabled, a return at the top level is not considered an
// error.
allowReturnOutsideFunction: false,
// When enabled, import/export statements are not constrained to
// appearing at the top of the program.
allowImportExportEverywhere: false,
- plugins: {},
- // Babel-specific options
- features: {},
- strictMode: null
+ // TODO
+ allowSuperOutsideMethod: false,
+ // An array of plugins to enable
+ plugins: [],
+ // TODO
+ strictMode: null,
};
// Interpret and default an options object
-export function getOptions(opts) {
+export function getOptions(opts?: Object): Object {
let options = {};
for (let key in defaultOptions) {
options[key] = opts && key in opts ? opts[key] : defaultOptions[key];
diff --git a/src/parser/comments.js b/src/parser/comments.js
index 39aa197872..344ba7e2c0 100644
--- a/src/parser/comments.js
+++ b/src/parser/comments.js
@@ -1,3 +1,5 @@
+/* @flow */
+
/**
* Based on the comment attachment algorithm used in espree and estraverse.
*
@@ -38,9 +40,9 @@ pp.addComment = function (comment) {
pp.processComment = function (node) {
if (node.type === "Program" && node.body.length > 0) return;
- var stack = this.state.commentStack;
+ let stack = this.state.commentStack;
- var lastChild, trailingComments, i;
+ let lastChild, trailingComments, i;
if (this.state.trailingComments.length > 0) {
// If the first comment in trailingComments comes after the
@@ -60,7 +62,7 @@ pp.processComment = function (node) {
this.state.trailingComments.length = 0;
}
} else {
- var lastInStack = last(stack);
+ let lastInStack = last(stack);
if (stack.length > 0 && lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {
trailingComments = lastInStack.trailingComments;
lastInStack.trailingComments = null;
@@ -78,7 +80,7 @@ pp.processComment = function (node) {
node.leadingComments = lastChild.leadingComments;
lastChild.leadingComments = null;
} else {
- // A leading comment for an anonymous class had been stolen by its first MethodDefinition,
+ // A leading comment for an anonymous class had been stolen by its first ClassMethod,
// so this takes back the leading comment.
// See also: https://github.com/eslint/espree/issues/158
for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {
diff --git a/src/parser/expression.js b/src/parser/expression.js
index 5faf80afce..b27bf3abd2 100644
--- a/src/parser/expression.js
+++ b/src/parser/expression.js
@@ -1,3 +1,5 @@
+/* @flow */
+
// A recursive descent parser operates by defining functions for all
// syntactic elements, and recursively calling those, each function
// advancing the input stream and returning an AST node. Precedence
@@ -28,17 +30,25 @@ const pp = Parser.prototype;
// strict mode, init properties are also not allowed to be repeated.
pp.checkPropClash = function (prop, propHash) {
- if (prop.computed || prop.method || prop.shorthand) return;
+ if (prop.computed || prop.method) return;
- let key = prop.key, name;
+ let key = prop.key;
+ let name;
switch (key.type) {
- case "Identifier": name = key.name; break;
- case "Literal": name = String(key.value); break;
- default: return;
+ case "Identifier":
+ name = key.name;
+ break;
+
+ case "StringLiteral":
+ case "NumberLiteral":
+ name = String(key.value);
+ break;
+
+ default:
+ return;
}
- let kind = prop.kind;
- if (name === "__proto__" && kind === "init") {
+ if (name === "__proto__" && prop.kind === "init") {
if (propHash.proto) this.raise(key.start, "Redefinition of __proto__ property");
propHash.proto = true;
}
@@ -101,7 +111,7 @@ pp.parseMaybeAssign = function (noIn, refShorthandDefaultPos, afterLeftParse) {
node.left = this.match(tt.eq) ? this.toAssignable(left) : left;
refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
this.checkLVal(left);
- if (left.parenthesizedExpression) {
+ if (left.extra && left.extra.parenthesized) {
let errorMsg;
if (left.type === "ObjectPattern") {
errorMsg = "`({a}) = 0` use `({a} = 0)`";
@@ -186,7 +196,7 @@ pp.parseMaybeUnary = function (refShorthandDefaultPos) {
if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
if (update) {
this.checkLVal(node.argument);
- } else if (this.strict && node.operator === "delete" && node.argument.type === "Identifier") {
+ } else if (this.state.strict && node.operator === "delete" && node.argument.type === "Identifier") {
this.raise(node.start, "Deleting local variable in strict mode");
}
return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
@@ -215,11 +225,11 @@ pp.parseExprSubscripts = function (refShorthandDefaultPos) {
if (refShorthandDefaultPos && refShorthandDefaultPos.start) {
return expr;
} else {
- return this.parseSubscripts(expr, startPos, startLoc);
+ return this.parseSubscripts(expr, startPos, startLoc);
}
};
-pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+pp.parseSubscripts = function (base, startPos, startLoc, noCalls) {
for (;;) {
if (!noCalls && this.eat(tt.doubleColon)) {
let node = this.startNodeAt(startPos, startLoc);
@@ -229,7 +239,7 @@ pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
} else if (this.eat(tt.dot)) {
let node = this.startNodeAt(startPos, startLoc);
node.object = base;
- node.property = this.parseIdent(true);
+ node.property = this.parseIdentifier(true);
node.computed = false;
base = this.finishNode(node, "MemberExpression");
} else if (this.eat(tt.bracketL)) {
@@ -245,11 +255,11 @@ pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
let node = this.startNodeAt(startPos, startLoc);
node.callee = base;
- node.arguments = this.parseExprList(tt.parenR, this.options.features["es7.trailingFunctionCommas"]);
+ node.arguments = this.parseCallExpressionArguments(tt.parenR, this.hasPlugin("trailingFunctionCommas"), possibleAsync);
base = this.finishNode(node, "CallExpression");
- if (possibleAsync && (this.match(tt.colon) || this.match(tt.arrow))) {
- base = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);
+ if (possibleAsync && this.shouldParseAsyncArrow()) {
+ return this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);
} else {
this.toReferencedList(node.arguments);
}
@@ -264,8 +274,40 @@ pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
}
};
+pp.parseCallExpressionArguments = function (close, allowTrailingComma, possibleAsyncArrow) {
+ let innerParenStart;
+
+ let elts = [], first = true;
+ while (!this.eat(close)) {
+ if (first) {
+ first = false;
+ } else {
+ this.expect(tt.comma);
+ if (allowTrailingComma && this.eat(close)) break;
+ }
+
+ // we need to make sure that if this is an async arrow functions, that we don't allow inner parens inside the params
+ if (this.match(tt.parenL) && !innerParenStart) {
+ innerParenStart = this.state.start;
+ }
+
+ elts.push(this.parseExprListItem());
+ }
+
+ // we found an async arrow function so let's not allow any inner parens
+ if (possibleAsyncArrow && innerParenStart && this.shouldParseAsyncArrow()) {
+ this.unexpected();
+ }
+
+ return elts;
+};
+
+pp.shouldParseAsyncArrow = function () {
+ return this.match(tt.arrow);
+};
+
pp.parseAsyncArrowFromCallExpression = function (node, call) {
- if (!this.options.features["es7.asyncFunctions"]) this.unexpected();
+ if (!this.hasPlugin("asyncFunctions")) this.unexpected();
this.expect(tt.arrow);
return this.parseArrowExpression(node, call.arguments, true);
};
@@ -286,45 +328,46 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
let node, canBeArrow = this.state.potentialArrowAt === this.state.start;
switch (this.state.type) {
case tt._super:
- if (!this.state.inFunction)
+ if (!this.state.inMethod && !this.options.allowSuperOutsideMethod) {
this.raise(this.state.start, "'super' outside of function or class");
- case tt._this:
- let type = this.match(tt._this) ? "ThisExpression" : "Super";
+ }
+
node = this.startNode();
this.next();
- return this.finishNode(node, type);
+ if (!this.match(tt.parenL) && !this.match(tt.bracketL) && !this.match(tt.dot)) {
+ this.unexpected();
+ }
+ if (this.match(tt.parenL) && this.state.inMethod !== "constructor" && !this.options.allowSuperOutsideMethod) {
+ this.raise(node.start, "super() outside of class constructor");
+ }
+ return this.finishNode(node, "Super");
+
+ case tt._this:
+ node = this.startNode();
+ this.next();
+ return this.finishNode(node, "ThisExpression");
case tt._yield:
if (this.state.inGenerator) this.unexpected();
- case tt._do:
- if (this.options.features["es7.doExpressions"]) {
- let node = this.startNode();
- this.next();
- var oldInFunction = this.state.inFunction;
- var oldLabels = this.state.labels;
- this.state.labels = [];
- this.state.inFunction = false;
- node.body = this.parseBlock();
- this.state.inFunction = oldInFunction;
- this.state.labels = oldLabels;
- return this.finishNode(node, "DoExpression");
- }
-
case tt.name:
node = this.startNode();
- let id = this.parseIdent(true);
+ let allowAwait = this.hasPlugin("asyncFunctions") && this.state.value === "await" && this.state.inAsync;
+ let allowYield = this.shouldAllowYieldIdentifier();
+ let id = this.parseIdentifier(allowAwait || allowYield);
- if (this.options.features["es7.asyncFunctions"]) {
+ if (this.hasPlugin("asyncFunctions")) {
if (id.name === "await") {
- if (this.inAsync) return this.parseAwait(node);
+ if (this.state.inAsync || this.inModule) {
+ return this.parseAwait(node);
+ }
} else if (id.name === "async" && this.match(tt._function) && !this.canInsertSemicolon()) {
this.next();
return this.parseFunction(node, false, false, true);
} else if (canBeArrow && id.name === "async" && this.match(tt.name)) {
- var params = [this.parseIdent()];
+ let params = [this.parseIdentifier()];
this.expect(tt.arrow);
- // var foo = bar => {};
+ // let foo = bar => {};
return this.parseArrowExpression(node, params, true);
}
}
@@ -335,21 +378,43 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
return id;
+ case tt._do:
+ if (this.hasPlugin("doExpressions")) {
+ let node = this.startNode();
+ this.next();
+ let oldInFunction = this.state.inFunction;
+ let oldLabels = this.state.labels;
+ this.state.labels = [];
+ this.state.inFunction = false;
+ node.body = this.parseBlock(false, true);
+ this.state.inFunction = oldInFunction;
+ this.state.labels = oldLabels;
+ return this.finishNode(node, "DoExpression");
+ }
+
case tt.regexp:
let value = this.state.value;
- node = this.parseLiteral(value.value);
- node.regex = {pattern: value.pattern, flags: value.flags};
+ node = this.parseLiteral(value.value, "RegexLiteral");
+ node.pattern = value.pattern;
+ node.flags = value.flags;
return node;
- case tt.num: case tt.string:
- return this.parseLiteral(this.state.value);
+ case tt.num:
+ return this.parseLiteral(this.state.value, "NumberLiteral");
- case tt._null: case tt._true: case tt._false:
+ case tt.string:
+ return this.parseLiteral(this.state.value, "StringLiteral");
+
+ case tt._null:
node = this.startNode();
- node.rawValue = node.value = this.match(tt._null) ? null : this.match(tt._true);
- node.raw = this.state.type.keyword;
this.next();
- return this.finishNode(node, "Literal");
+ return this.finishNode(node, "NullLiteral");
+
+ case tt._true: case tt._false:
+ node = this.startNode();
+ node.value = this.match(tt._true);
+ this.next();
+ return this.finishNode(node, "BooleanLiteral");
case tt.parenL:
return this.parseParenAndDistinguishExpression(null, null, canBeArrow);
@@ -357,10 +422,6 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
case tt.bracketL:
node = this.startNode();
this.next();
- // check whether this is array comprehension or regular array
- if (this.options.features["es7.comprehensions"] && this.match(tt._for)) {
- return this.parseComprehension(node, false);
- }
node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
this.toReferencedList(node.elements);
return this.finishNode(node, "ArrayExpression");
@@ -403,12 +464,13 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
}
};
-pp.parseLiteral = function (value) {
+pp.parseLiteral = function (value, type) {
let node = this.startNode();
- node.rawValue = node.value = value;
- node.raw = this.input.slice(this.state.start, this.state.end);
+ this.addExtra(node, "rawValue", value);
+ this.addExtra(node, "raw", this.input.slice(this.state.start, this.state.end));
+ node.value = value;
this.next();
- return this.finishNode(node, "Literal");
+ return this.finishNode(node, type);
};
pp.parseParenExpression = function () {
@@ -424,19 +486,15 @@ pp.parseParenAndDistinguishExpression = function (startPos, startLoc, canBeArrow
let val;
this.next();
- if (this.options.features["es7.comprehensions"] && this.match(tt._for)) {
- return this.parseComprehension(this.startNodeAt(startPos, startLoc), true);
- }
-
let innerStartPos = this.state.start, innerStartLoc = this.state.startLoc;
let exprList = [], first = true;
- let refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart, optionalCommaStart;
+ let refShorthandDefaultPos = { start: 0 }, spreadStart, innerParenStart, optionalCommaStart;
while (!this.match(tt.parenR)) {
if (first) {
first = false;
} else {
this.expect(tt.comma);
- if (this.match(tt.parenR) && this.options.features["es7.trailingFunctionCommas"]) {
+ if (this.match(tt.parenR) && this.hasPlugin("trailingFunctionCommas")) {
optionalCommaStart = this.state.start;
break;
}
@@ -454,6 +512,7 @@ pp.parseParenAndDistinguishExpression = function (startPos, startLoc, canBeArrow
exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos, this.parseParenItem));
}
}
+
let innerEndPos = this.state.start;
let innerEndLoc = this.state.startLoc;
this.expect(tt.parenR);
@@ -482,8 +541,7 @@ pp.parseParenAndDistinguishExpression = function (startPos, startLoc, canBeArrow
} else {
val = exprList[0];
}
-
- val.parenthesizedExpression = true;
+ this.addExtra(val, "parenthesized", true);
return val;
};
@@ -497,11 +555,11 @@ pp.parseParenItem = function (node) {
pp.parseNew = function () {
let node = this.startNode();
- let meta = this.parseIdent(true);
+ let meta = this.parseIdentifier(true);
if (this.eat(tt.dot)) {
node.meta = meta;
- node.property = this.parseIdent(true);
+ node.property = this.parseIdentifier(true);
if (node.property.name !== "target") {
this.raise(node.property.start, "The only valid meta property for new is new.target");
@@ -513,7 +571,7 @@ pp.parseNew = function () {
node.callee = this.parseNoCallExpr();
if (this.eat(tt.parenL)) {
- node.arguments = this.parseExprList(tt.parenR, this.options.features["es7.trailingFunctionCommas"]);
+ node.arguments = this.parseExprList(tt.parenR, this.hasPlugin("trailingFunctionCommas"));
this.toReferencedList(node.arguments);
} else {
node.arguments = [];
@@ -554,10 +612,14 @@ pp.parseTemplate = function () {
// Parse an object literal or binding pattern.
pp.parseObj = function (isPattern, refShorthandDefaultPos) {
- let node = this.startNode(), first = true, propHash = Object.create(null);
- node.properties = [];
let decorators = [];
+ let propHash = Object.create(null);
+ let first = true;
+ let node = this.startNode();
+
+ node.properties = [];
this.next();
+
while (!this.eat(tt.braceR)) {
if (first) {
first = false;
@@ -575,24 +637,30 @@ pp.parseObj = function (isPattern, refShorthandDefaultPos) {
prop.decorators = decorators;
decorators = [];
}
- if (this.options.features["es7.objectRestSpread"] && this.match(tt.ellipsis)) {
+
+ if (this.hasPlugin("objectRestSpread") && this.match(tt.ellipsis)) {
prop = this.parseSpread();
- prop.type = "SpreadProperty";
+ prop.type = isPattern ? "RestProperty" : "SpreadProperty";
node.properties.push(prop);
continue;
}
+
prop.method = false;
prop.shorthand = false;
+
if (isPattern || refShorthandDefaultPos) {
startPos = this.state.start;
startLoc = this.state.startLoc;
}
+
if (!isPattern) {
isGenerator = this.eat(tt.star);
}
- if (!isPattern && this.options.features["es7.asyncFunctions"] && this.isContextual("async")) {
+
+ if (!isPattern && this.hasPlugin("asyncFunctions") && this.isContextual("async")) {
if (isGenerator) this.unexpected();
- var asyncId = this.parseIdent();
+
+ let asyncId = this.parseIdentifier();
if (this.match(tt.colon) || this.match(tt.parenL) || this.match(tt.braceR)) {
prop.key = asyncId;
} else {
@@ -602,57 +670,78 @@ pp.parseObj = function (isPattern, refShorthandDefaultPos) {
} else {
this.parsePropertyName(prop);
}
+
this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, refShorthandDefaultPos);
this.checkPropClash(prop, propHash);
- node.properties.push(this.finishNode(prop, "Property"));
+
+ if (prop.shorthand) {
+ this.addExtra(prop, "shorthand", true);
+ }
+
+ node.properties.push(prop);
}
+
if (decorators.length) {
this.raise(this.state.start, "You have trailing decorators with no property");
}
+
return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
};
pp.parseObjPropValue = function (prop, startPos, startLoc, isGenerator, isAsync, isPattern, refShorthandDefaultPos) {
if (this.eat(tt.colon)) {
prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssign(false, refShorthandDefaultPos);
- prop.kind = "init";
- } else if (this.match(tt.parenL)) {
+ return this.finishNode(prop, "ObjectProperty");
+ }
+
+ if (this.match(tt.parenL)) {
if (isPattern) this.unexpected();
- prop.kind = "init";
+ prop.kind = "method";
prop.method = true;
- prop.value = this.parseMethod(isGenerator, isAsync);
- } else if (!prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (!this.match(tt.comma) && !this.match(tt.braceR))) {
+ this.parseMethod(prop, isGenerator, isAsync);
+ return this.finishNode(prop, "ObjectMethod");
+ }
+
+ if (!prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (!this.match(tt.comma) && !this.match(tt.braceR))) {
if (isGenerator || isAsync || isPattern) this.unexpected();
prop.kind = prop.key.name;
this.parsePropertyName(prop);
- prop.value = this.parseMethod(false);
+ this.parseMethod(prop, false);
let paramCount = prop.kind === "get" ? 0 : 1;
- if (prop.value.params.length !== paramCount) {
- let start = prop.value.start;
- if (prop.kind === "get")
+ if (prop.params.length !== paramCount) {
+ let start = prop.start;
+ if (prop.kind === "get") {
this.raise(start, "getter should have no params");
- else
+ } else {
this.raise(start, "setter should have exactly one param");
+ }
}
- } else if (!prop.computed && prop.key.type === "Identifier") {
- prop.kind = "init";
+ return this.finishNode(prop, "ObjectMethod");
+ }
+
+ if (!prop.computed && prop.key.type === "Identifier") {
if (isPattern) {
- if (this.isKeyword(prop.key.name) ||
- (this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name))) ||
- (!this.options.allowReserved && this.isReservedWord(prop.key.name)))
- this.raise(prop.key.start, "Binding " + prop.key.name);
+ let illegalBinding = this.isKeyword(prop.key.name);
+ if (!illegalBinding && this.state.strict) {
+ illegalBinding = reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name);
+ }
+ if (illegalBinding) {
+ this.raise(prop.key.start, "Binding " + prop.key.name);
+ }
prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());
} else if (this.match(tt.eq) && refShorthandDefaultPos) {
- if (!refShorthandDefaultPos.start)
+ if (!refShorthandDefaultPos.start) {
refShorthandDefaultPos.start = this.state.start;
+ }
prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());
} else {
prop.value = prop.key.__clone();
}
prop.shorthand = true;
- } else {
- this.unexpected();
+ return this.finishNode(prop, "ObjectProperty");
}
+
+ this.unexpected();
};
pp.parsePropertyName = function (prop) {
@@ -663,7 +752,7 @@ pp.parsePropertyName = function (prop) {
return prop.key;
} else {
prop.computed = false;
- return prop.key = (this.match(tt.num) || this.match(tt.string)) ? this.parseExprAtom() : this.parseIdent(true);
+ return prop.key = (this.match(tt.num) || this.match(tt.string)) ? this.parseExprAtom() : this.parseIdentifier(true);
}
};
@@ -673,21 +762,23 @@ pp.initFunction = function (node, isAsync) {
node.id = null;
node.generator = false;
node.expression = false;
- if (this.options.features["es7.asyncFunctions"]) {
+ if (this.hasPlugin("asyncFunctions")) {
node.async = !!isAsync;
}
};
// Parse object or class method.
-pp.parseMethod = function (isGenerator, isAsync) {
- let node = this.startNode();
+pp.parseMethod = function (node, isGenerator, isAsync) {
+ let oldInMethod = this.state.inMethod;
+ this.state.inMethod = node.kind || true;
this.initFunction(node, isAsync);
this.expect(tt.parenL);
- node.params = this.parseBindingList(tt.parenR, false, this.options.features["es7.trailingFunctionCommas"]);
+ node.params = this.parseBindingList(tt.parenR, false, this.hasPlugin("trailingFunctionCommas"));
node.generator = isGenerator;
this.parseFunctionBody(node);
- return this.finishNode(node, "FunctionExpression");
+ this.state.inMethod = oldInMethod;
+ return node;
};
// Parse arrow function expression with given parameters.
@@ -704,8 +795,8 @@ pp.parseArrowExpression = function (node, params, isAsync) {
pp.parseFunctionBody = function (node, allowExpression) {
let isExpression = allowExpression && !this.match(tt.braceL);
- var oldInAsync = this.inAsync;
- this.inAsync = node.async;
+ let oldInAsync = this.state.inAsync;
+ this.state.inAsync = node.async;
if (isExpression) {
node.body = this.parseMaybeAssign();
node.expression = true;
@@ -718,21 +809,46 @@ pp.parseFunctionBody = function (node, allowExpression) {
node.expression = false;
this.state.inFunction = oldInFunc; this.state.inGenerator = oldInGen; this.state.labels = oldLabels;
}
- this.inAsync = oldInAsync;
+ this.state.inAsync = oldInAsync;
// If this is a strict mode function, verify that argument names
// are not repeated, and it does not try to bind the words `eval`
// or `arguments`.
- if (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
- let nameHash = Object.create(null), oldStrict = this.strict;
- this.strict = true;
+ let checkLVal = this.state.strict;
+ let checkLValStrict = false;
+ let isStrict = false;
+
+ // arrow function
+ if (allowExpression) checkLVal = true;
+
+ // normal function
+ if (!isExpression && node.body.directives.length) {
+ for (let directive of (node.body.directives: Array