"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.default = void 0;
|
exports.newArrowHeadScope = newArrowHeadScope;
|
exports.newAsyncArrowScope = newAsyncArrowScope;
|
exports.newExpressionScope = newExpressionScope;
|
exports.newParameterDeclarationScope = newParameterDeclarationScope;
|
var _parseError = require("../parse-error");
|
const kExpression = 0,
|
kMaybeArrowParameterDeclaration = 1,
|
kMaybeAsyncArrowParameterDeclaration = 2,
|
kParameterDeclaration = 3;
|
class ExpressionScope {
|
constructor(type = kExpression) {
|
this.type = void 0;
|
this.type = type;
|
}
|
canBeArrowParameterDeclaration() {
|
return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration;
|
}
|
isCertainlyParameterDeclaration() {
|
return this.type === kParameterDeclaration;
|
}
|
}
|
class ArrowHeadParsingScope extends ExpressionScope {
|
constructor(type) {
|
super(type);
|
this.declarationErrors = new Map();
|
}
|
recordDeclarationError(ParsingErrorClass, {
|
at
|
}) {
|
const index = at.index;
|
this.declarationErrors.set(index, [ParsingErrorClass, at]);
|
}
|
clearDeclarationError(index) {
|
this.declarationErrors.delete(index);
|
}
|
iterateErrors(iterator) {
|
this.declarationErrors.forEach(iterator);
|
}
|
}
|
class ExpressionScopeHandler {
|
constructor(parser) {
|
this.parser = void 0;
|
this.stack = [new ExpressionScope()];
|
this.parser = parser;
|
}
|
enter(scope) {
|
this.stack.push(scope);
|
}
|
exit() {
|
this.stack.pop();
|
}
|
recordParameterInitializerError(toParseError, {
|
at: node
|
}) {
|
const origin = {
|
at: node.loc.start
|
};
|
const {
|
stack
|
} = this;
|
let i = stack.length - 1;
|
let scope = stack[i];
|
while (!scope.isCertainlyParameterDeclaration()) {
|
if (scope.canBeArrowParameterDeclaration()) {
|
scope.recordDeclarationError(toParseError, origin);
|
} else {
|
return;
|
}
|
scope = stack[--i];
|
}
|
this.parser.raise(toParseError, origin);
|
}
|
recordArrowParameterBindingError(error, {
|
at: node
|
}) {
|
const {
|
stack
|
} = this;
|
const scope = stack[stack.length - 1];
|
const origin = {
|
at: node.loc.start
|
};
|
if (scope.isCertainlyParameterDeclaration()) {
|
this.parser.raise(error, origin);
|
} else if (scope.canBeArrowParameterDeclaration()) {
|
scope.recordDeclarationError(error, origin);
|
} else {
|
return;
|
}
|
}
|
recordAsyncArrowParametersError({
|
at
|
}) {
|
const {
|
stack
|
} = this;
|
let i = stack.length - 1;
|
let scope = stack[i];
|
while (scope.canBeArrowParameterDeclaration()) {
|
if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
|
scope.recordDeclarationError(_parseError.Errors.AwaitBindingIdentifier, {
|
at
|
});
|
}
|
scope = stack[--i];
|
}
|
}
|
validateAsPattern() {
|
const {
|
stack
|
} = this;
|
const currentScope = stack[stack.length - 1];
|
if (!currentScope.canBeArrowParameterDeclaration()) return;
|
currentScope.iterateErrors(([toParseError, loc]) => {
|
this.parser.raise(toParseError, {
|
at: loc
|
});
|
let i = stack.length - 2;
|
let scope = stack[i];
|
while (scope.canBeArrowParameterDeclaration()) {
|
scope.clearDeclarationError(loc.index);
|
scope = stack[--i];
|
}
|
});
|
}
|
}
|
exports.default = ExpressionScopeHandler;
|
function newParameterDeclarationScope() {
|
return new ExpressionScope(kParameterDeclaration);
|
}
|
function newArrowHeadScope() {
|
return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
|
}
|
function newAsyncArrowScope() {
|
return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
|
}
|
function newExpressionScope() {
|
return new ExpressionScope();
|
}
|
|
//# sourceMappingURL=expression-scope.js.map
|
