98 lines
2.7 KiB
JavaScript
98 lines
2.7 KiB
JavaScript
/* */
|
|
"format cjs";
|
|
"use strict";
|
|
|
|
var _babelToolsProtectJs2 = require("./../../babel/tools/protect.js");
|
|
|
|
var _babelToolsProtectJs3 = _interopRequireDefault(_babelToolsProtectJs2);
|
|
|
|
var _tokentype = require("./tokentype");
|
|
|
|
var _state = require("./state");
|
|
|
|
var _whitespace = require("./whitespace");
|
|
|
|
_babelToolsProtectJs3["default"](module);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
var pp = _state.Parser.prototype;
|
|
|
|
// ## Parser utilities
|
|
|
|
// Test whether a statement node is the string literal `"use strict"`.
|
|
|
|
pp.isUseStrict = function (stmt) {
|
|
return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
|
|
};
|
|
|
|
// Predicate that tests whether the next token is of the given
|
|
// type, and if yes, consumes it as a side effect.
|
|
|
|
pp.eat = function (type) {
|
|
if (this.type === type) {
|
|
this.next();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Tests whether parsed token is a contextual keyword.
|
|
|
|
pp.isContextual = function (name) {
|
|
return this.type === _tokentype.types.name && this.value === name;
|
|
};
|
|
|
|
// Consumes contextual keyword if possible.
|
|
|
|
pp.eatContextual = function (name) {
|
|
return this.value === name && this.eat(_tokentype.types.name);
|
|
};
|
|
|
|
// Asserts that following token is given contextual keyword.
|
|
|
|
pp.expectContextual = function (name) {
|
|
if (!this.eatContextual(name)) this.unexpected();
|
|
};
|
|
|
|
// Test whether a semicolon can be inserted at the current position.
|
|
|
|
pp.canInsertSemicolon = function () {
|
|
return this.type === _tokentype.types.eof || this.type === _tokentype.types.braceR || _whitespace.lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
|
|
};
|
|
|
|
pp.insertSemicolon = function () {
|
|
if (this.canInsertSemicolon()) {
|
|
if (this.options.onInsertedSemicolon) this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Consume a semicolon, or, failing that, see if we are allowed to
|
|
// pretend that there is a semicolon at this position.
|
|
|
|
pp.semicolon = function () {
|
|
if (!this.eat(_tokentype.types.semi) && !this.insertSemicolon()) this.unexpected();
|
|
};
|
|
|
|
pp.afterTrailingComma = function (tokType) {
|
|
if (this.type == tokType) {
|
|
if (this.options.onTrailingComma) this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
|
|
this.next();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Expect a token of a given type. If found, consume it, otherwise,
|
|
// raise an unexpected token error.
|
|
|
|
pp.expect = function (type) {
|
|
this.eat(type) || this.unexpected();
|
|
};
|
|
|
|
// Raise an unexpected token error.
|
|
|
|
pp.unexpected = function (pos) {
|
|
this.raise(pos != null ? pos : this.start, "Unexpected token");
|
|
}; |