file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
crates/swc_ecma_parser/src/lib.rs | Rust | //! EcmaScript/TypeScript parser for the rust programming language.
//!
//! # Features
//!
//! ## Heavily tested
//!
//! Passes almost all tests from [tc39/test262][].
//!
//! ## Error reporting
//!
//! ```sh
//! error: 'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static', or 'yield' cannot be used as an identifier in strict mode
//! --> invalid.js:3:10
//! |
//! 3 | function yield() {
//! | ^^^^^
//! ```
//!
//! ## Error recovery
//!
//! The parser can recover from some parsing errors. For example, parser returns
//! `Ok(Module)` for the code below, while emitting error to handler.
//!
//! ```ts
//! const CONST = 9000 % 2;
//! const enum D {
//! // Comma is required, but parser can recover because of the newline.
//! d = 10
//! g = CONST
//! }
//! ```
//!
//! # Example (lexer)
//!
//! See `lexer.rs` in examples directory.
//!
//! # Example (parser)
//!
//! ```
//! #[macro_use]
//! extern crate swc_common;
//! extern crate swc_ecma_parser;
//! use swc_common::sync::Lrc;
//! use swc_common::{
//! errors::{ColorConfig, Handler},
//! FileName, FilePathMapping, SourceMap,
//! };
//! use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax};
//!
//! fn main() {
//! let cm: Lrc<SourceMap> = Default::default();
//! let handler =
//! Handler::with_tty_emitter(ColorConfig::Auto, true, false,
//! Some(cm.clone()));
//!
//! // Real usage
//! // let fm = cm
//! // .load_file(Path::new("test.js"))
//! // .expect("failed to load test.js");
//! let fm = cm.new_source_file(
//! FileName::Custom("test.js".into()).into(),
//! "function foo() {}".into(),
//! );
//! let lexer = Lexer::new(
//! // We want to parse ecmascript
//! Syntax::Es(Default::default()),
//! // EsVersion defaults to es5
//! Default::default(),
//! StringInput::from(&*fm),
//! None,
//! );
//!
//! let mut parser = Parser::new_from(lexer);
//!
//! for e in parser.take_errors() {
//! e.into_diagnostic(&handler).emit();
//! }
//!
//! let _module = parser
//! .parse_module()
//! .map_err(|mut e| {
//! // Unrecoverable fatal error occurred
//! e.into_diagnostic(&handler).emit()
//! })
//! .expect("failed to parser module");
//! }
//! ```
//!
//! ## Cargo features
//!
//! ### `typescript`
//!
//! Enables typescript parser.
//!
//! ### `verify`
//!
//! Verify more errors, using `swc_ecma_visit`.
//!
//! ## Known issues
//!
//! ### Null character after `\`
//!
//! Because [String] of rust should only contain valid utf-8 characters while
//! javascript allows non-utf8 characters, the parser stores invalid utf8
//! characters in escaped form.
//!
//! As a result, swc needs a way to distinguish invalid-utf8 code points and
//! input specified by the user. The parser stores a null character right after
//! `\\` for non-utf8 code points. Note that other parts of swc is aware of this
//! fact.
//!
//! Note that this can be changed at anytime with a breaking change.
//!
//! [tc39/test262]:https://github.com/tc39/test262
#![cfg_attr(docsrs, feature(doc_cfg))]
#![cfg_attr(test, feature(test))]
#![deny(clippy::all)]
#![deny(unused)]
#![allow(clippy::nonminimal_bool)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::unnecessary_unwrap)]
#![allow(clippy::vec_box)]
#![allow(clippy::wrong_self_convention)]
#![allow(clippy::match_like_matches_macro)]
use error::Error;
use lexer::Lexer;
use serde::{Deserialize, Serialize};
pub use swc_common::input::{Input, StringInput};
use swc_common::{comments::Comments, input::SourceFileInput, SourceFile};
use swc_ecma_ast::*;
pub use self::parser::*;
#[macro_use]
mod macros;
#[macro_use]
pub mod token;
pub mod error;
pub mod lexer;
mod parser;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
#[serde(deny_unknown_fields, tag = "syntax")]
pub enum Syntax {
/// Standard
#[serde(rename = "ecmascript")]
Es(EsSyntax),
/// This variant requires the cargo feature `typescript` to be enabled.
#[cfg(feature = "typescript")]
#[cfg_attr(docsrs, doc(cfg(feature = "typescript")))]
#[serde(rename = "typescript")]
Typescript(TsSyntax),
}
impl Default for Syntax {
fn default() -> Self {
Syntax::Es(Default::default())
}
}
impl Syntax {
fn auto_accessors(self) -> bool {
match self {
Syntax::Es(EsSyntax {
auto_accessors: true,
..
}) => true,
#[cfg(feature = "typescript")]
Syntax::Typescript(_) => true,
_ => false,
}
}
pub fn import_attributes(self) -> bool {
match self {
Syntax::Es(EsSyntax {
import_attributes, ..
}) => import_attributes,
#[cfg(feature = "typescript")]
Syntax::Typescript(_) => true,
}
}
/// Should we parse jsx?
pub fn jsx(self) -> bool {
match self {
Syntax::Es(EsSyntax { jsx: true, .. }) => true,
#[cfg(feature = "typescript")]
Syntax::Typescript(TsSyntax { tsx: true, .. }) => true,
_ => false,
}
}
pub fn fn_bind(self) -> bool {
matches!(self, Syntax::Es(EsSyntax { fn_bind: true, .. }))
}
pub fn decorators(self) -> bool {
match self {
Syntax::Es(EsSyntax {
decorators: true, ..
}) => true,
#[cfg(feature = "typescript")]
Syntax::Typescript(TsSyntax {
decorators: true, ..
}) => true,
_ => false,
}
}
pub fn decorators_before_export(self) -> bool {
match self {
Syntax::Es(EsSyntax {
decorators_before_export: true,
..
}) => true,
#[cfg(feature = "typescript")]
Syntax::Typescript(..) => true,
_ => false,
}
}
/// Should we parse typescript?
#[cfg(not(feature = "typescript"))]
pub const fn typescript(self) -> bool {
false
}
/// Should we parse typescript?
#[cfg(feature = "typescript")]
pub const fn typescript(self) -> bool {
matches!(self, Syntax::Typescript(..))
}
pub fn export_default_from(self) -> bool {
matches!(
self,
Syntax::Es(EsSyntax {
export_default_from: true,
..
})
)
}
pub fn dts(self) -> bool {
match self {
#[cfg(feature = "typescript")]
Syntax::Typescript(t) => t.dts,
_ => false,
}
}
pub(crate) fn allow_super_outside_method(self) -> bool {
match self {
Syntax::Es(EsSyntax {
allow_super_outside_method,
..
}) => allow_super_outside_method,
#[cfg(feature = "typescript")]
Syntax::Typescript(_) => true,
}
}
pub(crate) fn allow_return_outside_function(self) -> bool {
match self {
Syntax::Es(EsSyntax {
allow_return_outside_function,
..
}) => allow_return_outside_function,
#[cfg(feature = "typescript")]
Syntax::Typescript(_) => false,
}
}
pub(crate) fn early_errors(self) -> bool {
match self {
#[cfg(feature = "typescript")]
Syntax::Typescript(t) => !t.no_early_errors,
Syntax::Es(..) => true,
}
}
fn disallow_ambiguous_jsx_like(self) -> bool {
match self {
#[cfg(feature = "typescript")]
Syntax::Typescript(t) => t.disallow_ambiguous_jsx_like,
_ => false,
}
}
pub fn explicit_resource_management(&self) -> bool {
match self {
Syntax::Es(EsSyntax {
explicit_resource_management: using_decl,
..
}) => *using_decl,
#[cfg(feature = "typescript")]
Syntax::Typescript(_) => true,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TsSyntax {
#[serde(default)]
pub tsx: bool,
#[serde(default)]
pub decorators: bool,
/// `.d.ts`
#[serde(skip, default)]
pub dts: bool,
#[serde(skip, default)]
pub no_early_errors: bool,
/// babel: `disallowAmbiguousJSXLike`
/// Even when JSX parsing is not enabled, this option disallows using syntax
/// that would be ambiguous with JSX (`<X> y` type assertions and
/// `<X>()=>{}` type arguments)
/// see: https://babeljs.io/docs/en/babel-plugin-transform-typescript#disallowambiguousjsxlike
#[serde(skip, default)]
pub disallow_ambiguous_jsx_like: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EsSyntax {
#[serde(default)]
pub jsx: bool,
/// Support function bind expression.
#[serde(rename = "functionBind")]
#[serde(default)]
pub fn_bind: bool,
/// Enable decorators.
#[serde(default)]
pub decorators: bool,
/// babel: `decorators.decoratorsBeforeExport`
///
/// Effective only if `decorator` is true.
#[serde(rename = "decoratorsBeforeExport")]
#[serde(default)]
pub decorators_before_export: bool,
#[serde(default)]
pub export_default_from: bool,
/// Stage 3.
#[serde(default, alias = "importAssertions")]
pub import_attributes: bool,
#[serde(default, rename = "allowSuperOutsideMethod")]
pub allow_super_outside_method: bool,
#[serde(default, rename = "allowReturnOutsideFunction")]
pub allow_return_outside_function: bool,
#[serde(default)]
pub auto_accessors: bool,
#[serde(default)]
pub explicit_resource_management: bool,
}
/// Syntactic context.
#[derive(Debug, Clone, Copy, Default)]
pub struct Context {
/// `true` while backtracking
ignore_error: bool,
/// Is in module code?
module: bool,
can_be_module: bool,
strict: bool,
expr_ctx: ExpressionContext,
include_in_expr: bool,
/// If true, await expression is parsed, and "await" is treated as a
/// keyword.
in_async: bool,
/// If true, yield expression is parsed, and "yield" is treated as a
/// keyword.
in_generator: bool,
/// If true, await is treated as a keyword.
in_static_block: bool,
is_continue_allowed: bool,
is_break_allowed: bool,
in_type: bool,
/// Typescript extension.
should_not_lex_lt_or_gt_as_type: bool,
/// Typescript extension.
in_declare: bool,
/// If true, `:` should not be treated as a type annotation.
in_cond_expr: bool,
will_expect_colon_for_cond: bool,
in_class: bool,
in_class_field: bool,
in_function: bool,
/// This indicates current scope or the scope out of arrow function is
/// function declaration or function expression or not.
inside_non_arrow_function_scope: bool,
in_parameters: bool,
has_super_class: bool,
in_property_name: bool,
in_forced_jsx_context: bool,
// If true, allow super.x and super[x]
allow_direct_super: bool,
ignore_else_clause: bool,
disallow_conditional_types: bool,
allow_using_decl: bool,
}
#[derive(Debug, Clone, Copy, Default)]
struct ExpressionContext {
// TODO:
// - include_in
for_loop_init: bool,
for_await_loop_init: bool,
}
#[cfg(test)]
fn with_test_sess<F, Ret>(src: &str, f: F) -> Result<Ret, ::testing::StdErr>
where
F: FnOnce(&swc_common::errors::Handler, StringInput<'_>) -> Result<Ret, ()>,
{
use swc_common::FileName;
::testing::run_test(false, |cm, handler| {
let fm = cm.new_source_file(FileName::Real("testing".into()).into(), src.into());
f(handler, (&*fm).into())
})
}
pub fn with_file_parser<T>(
fm: &SourceFile,
syntax: Syntax,
target: EsVersion,
comments: Option<&dyn Comments>,
recovered_errors: &mut Vec<Error>,
op: impl for<'aa> FnOnce(&mut Parser<Lexer>) -> PResult<T>,
) -> PResult<T> {
let lexer = Lexer::new(syntax, target, SourceFileInput::from(fm), comments);
let mut p = Parser::new_from(lexer);
let ret = op(&mut p);
recovered_errors.append(&mut p.take_errors());
ret
}
macro_rules! expose {
(
$name:ident,
$T:ty,
$($t:tt)*
) => {
/// Note: This is recommended way to parse a file.
///
/// This is an alias for [Parser], [Lexer] and [SourceFileInput], but
/// instantiation of generics occur in `swc_ecma_parser` crate.
pub fn $name(
fm: &SourceFile,
syntax: Syntax,
target: EsVersion,
comments: Option<&dyn Comments>,
recovered_errors: &mut Vec<Error>,
) -> PResult<$T> {
with_file_parser(fm, syntax, target, comments, recovered_errors, $($t)*)
}
};
}
expose!(parse_file_as_expr, Box<Expr>, |p| {
// This allow to parse `import.meta`
p.input().ctx.can_be_module = true;
p.parse_expr()
});
expose!(parse_file_as_module, Module, |p| { p.parse_module() });
expose!(parse_file_as_script, Script, |p| { p.parse_script() });
expose!(parse_file_as_program, Program, |p| { p.parse_program() });
#[inline(always)]
#[cfg(any(
target_arch = "wasm32",
target_arch = "arm",
not(feature = "stacker"),
// miri does not work with stacker
miri
))]
fn maybe_grow<R, F: FnOnce() -> R>(_red_zone: usize, _stack_size: usize, callback: F) -> R {
callback()
}
#[inline(always)]
#[cfg(all(
not(any(target_arch = "wasm32", target_arch = "arm", miri)),
feature = "stacker"
))]
fn maybe_grow<R, F: FnOnce() -> R>(red_zone: usize, stack_size: usize, callback: F) -> R {
stacker::maybe_grow(red_zone, stack_size, callback)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/macros.rs | Rust | #[allow(unused)]
macro_rules! tok {
('`') => {
crate::token::Token::BackQuote
};
// (';') => { Token::Semi };
('@') => {
crate::token::Token::At
};
('#') => {
crate::token::Token::Hash
};
('&') => {
crate::token::Token::BinOp(crate::token::BinOpToken::BitAnd)
};
('|') => {
crate::token::Token::BinOp(crate::token::BinOpToken::BitOr)
};
('^') => {
crate::token::Token::BinOp(crate::token::BinOpToken::BitXor)
};
('+') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Add)
};
('-') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Sub)
};
("??") => {
crate::token::Token::BinOp(crate::token::BinOpToken::NullishCoalescing)
};
('~') => {
crate::token::Token::Tilde
};
('!') => {
crate::token::Token::Bang
};
("&&") => {
crate::token::Token::BinOp(crate::token::BinOpToken::LogicalAnd)
};
("||") => {
crate::token::Token::BinOp(crate::token::BinOpToken::LogicalOr)
};
("&&=") => {
crate::token::Token::AssignOp(swc_ecma_ast::AssignOp::AndAssign)
};
("||=") => {
crate::token::Token::AssignOp(swc_ecma_ast::AssignOp::OrAssign)
};
("??=") => {
crate::token::Token::AssignOp(swc_ecma_ast::AssignOp::NullishAssign)
};
("==") => {
crate::token::Token::BinOp(crate::token::BinOpToken::EqEq)
};
("===") => {
crate::token::Token::BinOp(crate::token::BinOpToken::EqEqEq)
};
("!=") => {
crate::token::Token::BinOp(crate::token::BinOpToken::NotEq)
};
("!==") => {
crate::token::Token::BinOp(crate::token::BinOpToken::NotEqEq)
};
(',') => {
crate::token::Token::Comma
};
('?') => {
crate::token::Token::QuestionMark
};
(':') => {
crate::token::Token::Colon
};
('.') => {
crate::token::Token::Dot
};
("=>") => {
crate::token::Token::Arrow
};
("...") => {
crate::token::Token::DotDotDot
};
("${") => {
crate::token::Token::DollarLBrace
};
('+') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Add)
};
('-') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Sub)
};
('*') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Mul)
};
('/') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Div)
};
("/=") => {
crate::token::Token::AssignOp(swc_ecma_ast::AssignOp::DivAssign)
};
('%') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Mod)
};
('~') => {
crate::token::Token::Tilde
};
('<') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Lt)
};
("<<") => {
crate::token::Token::BinOp(crate::token::BinOpToken::LShift)
};
("<=") => {
crate::token::Token::BinOp(crate::token::BinOpToken::LtEq)
};
("<<=") => {
crate::token::Token::AssignOp(crate::token::AssignOp::LShiftAssign)
};
('>') => {
crate::token::Token::BinOp(crate::token::BinOpToken::Gt)
};
(">>") => {
crate::token::Token::BinOp(crate::token::BinOpToken::RShift)
};
(">>>") => {
crate::token::Token::BinOp(crate::token::BinOpToken::ZeroFillRShift)
};
(">=") => {
crate::token::Token::BinOp(crate::token::BinOpToken::GtEq)
};
(">>=") => {
crate::token::Token::AssignOp(crate::AssignOp::RShiftAssign)
};
(">>>=") => {
crate::token::Token::AssignOp(crate::AssignOp::ZeroFillRShiftAssign)
};
("++") => {
crate::token::Token::PlusPlus
};
("--") => {
crate::token::Token::MinusMinus
};
('=') => {
crate::token::Token::AssignOp(swc_ecma_ast::AssignOp::Assign)
};
('(') => {
crate::token::Token::LParen
};
(')') => {
crate::token::Token::RParen
};
('{') => {
crate::token::Token::LBrace
};
('}') => {
crate::token::Token::RBrace
};
('[') => {
crate::token::Token::LBracket
};
(']') => {
crate::token::Token::RBracket
};
("await") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Await))
};
("break") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Break))
};
("case") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Case))
};
("catch") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Catch))
};
("class") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Class))
};
("const") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Const))
};
("continue") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Continue))
};
("debugger") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Debugger))
};
("default") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Default_))
};
("delete") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Delete))
};
("do") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Do))
};
("else") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Else))
};
("export") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Export))
};
("extends") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Extends))
};
("false") => {
crate::token::Token::Word(crate::token::Word::False)
};
("finally") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Finally))
};
("for") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::For))
};
("function") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Function))
};
("if") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::If))
};
("in") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::In))
};
("instanceof") => {
crate::token::Token::Word(crate::token::Word::Keyword(
crate::token::Keyword::InstanceOf,
))
};
("import") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Import))
};
("let") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Let))
};
("new") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::New))
};
("null") => {
crate::token::Token::Word(crate::token::Word::Null)
};
("return") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Return))
};
("super") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Super))
};
("switch") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Switch))
};
("this") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::This))
};
("throw") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Throw))
};
("true") => {
crate::token::Token::Word(crate::token::Word::True)
};
("try") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Try))
};
("typeof") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::TypeOf))
};
("var") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Var))
};
("void") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Void))
};
("while") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::While))
};
("with") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::With))
};
("yield") => {
crate::token::Token::Word(crate::token::Word::Keyword(crate::token::Keyword::Yield))
};
// ----------
// JSX
// ----------
(JSXTagStart) => {
crate::token::Token::JSXTagStart
};
(JSXTagEnd) => {
crate::token::Token::JSXTagEnd
};
($tt:tt) => {
crate::token::Token::Word(crate::token::Word::Ident(crate::token::IdentLike::Known(
known_ident!($tt),
)))
};
}
macro_rules! token_including_semi {
(';') => {
Token::Semi
};
($t:tt) => {
tok!($t)
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/class_and_fn.rs | Rust | use swc_common::Spanned;
use super::*;
use crate::lexer::TokenContext;
/// Parser for function expression and function declaration.
impl<I: Tokens> Parser<I> {
pub(super) fn parse_async_fn_expr(&mut self) -> PResult<Box<Expr>> {
let start = cur_pos!(self);
expect!(self, "async");
self.parse_fn(None, Some(start), Vec::new())
}
/// Parse function expression
pub(super) fn parse_fn_expr(&mut self) -> PResult<Box<Expr>> {
self.parse_fn(None, None, Vec::new())
}
pub(super) fn parse_async_fn_decl(&mut self, decorators: Vec<Decorator>) -> PResult<Decl> {
let start = cur_pos!(self);
expect!(self, "async");
self.parse_fn(None, Some(start), decorators)
}
pub(super) fn parse_fn_decl(&mut self, decorators: Vec<Decorator>) -> PResult<Decl> {
self.parse_fn(None, None, decorators)
}
pub(super) fn parse_default_async_fn(
&mut self,
start: BytePos,
decorators: Vec<Decorator>,
) -> PResult<ExportDefaultDecl> {
let start_of_async = cur_pos!(self);
expect!(self, "async");
self.parse_fn(Some(start), Some(start_of_async), decorators)
}
pub(super) fn parse_default_fn(
&mut self,
start: BytePos,
decorators: Vec<Decorator>,
) -> PResult<ExportDefaultDecl> {
self.parse_fn(Some(start), None, decorators)
}
pub(super) fn parse_class_decl(
&mut self,
start: BytePos,
class_start: BytePos,
decorators: Vec<Decorator>,
is_abstract: bool,
) -> PResult<Decl> {
self.parse_class(start, class_start, decorators, is_abstract)
}
pub(super) fn parse_class_expr(
&mut self,
start: BytePos,
decorators: Vec<Decorator>,
) -> PResult<Box<Expr>> {
self.parse_class(start, start, decorators, false)
}
pub(super) fn parse_default_class(
&mut self,
start: BytePos,
class_start: BytePos,
decorators: Vec<Decorator>,
is_abstract: bool,
) -> PResult<ExportDefaultDecl> {
self.parse_class(start, class_start, decorators, is_abstract)
}
/// Not generic
fn parse_class_inner(
&mut self,
_start: BytePos,
class_start: BytePos,
decorators: Vec<Decorator>,
is_ident_required: bool,
) -> PResult<(Option<Ident>, Box<Class>)> {
self.strict_mode().parse_with(|p| {
expect!(p, "class");
let ident = p
.parse_maybe_opt_binding_ident(is_ident_required, true)?
.map(Ident::from);
if p.input.syntax().typescript() {
if let Some(span) = ident.invalid_class_name() {
p.emit_err(span, SyntaxError::TS2414);
}
}
let type_params = if p.input.syntax().typescript() {
p.try_parse_ts_type_params(true, true)?
} else {
None
};
let (mut super_class, mut super_type_params) = if eat!(p, "extends") {
let (super_class, super_type_params) = p.parse_super_class()?;
if p.syntax().typescript() && eat!(p, ',') {
let exprs = p.parse_ts_heritage_clause()?;
for e in &exprs {
p.emit_err(e.span(), SyntaxError::TS1174);
}
}
(Some(super_class), super_type_params)
} else {
(None, None)
};
// Handle TS1172
if eat!(p, "extends") {
p.emit_err(p.input.prev_span(), SyntaxError::TS1172);
p.parse_super_class()?;
};
let implements = if p.input.syntax().typescript() && eat!(p, "implements") {
p.parse_ts_heritage_clause()?
} else {
Vec::new()
};
{
// Handle TS1175
if p.input.syntax().typescript() && eat!(p, "implements") {
p.emit_err(p.input.prev_span(), SyntaxError::TS1175);
p.parse_ts_heritage_clause()?;
}
}
// Handle TS1173
if p.input.syntax().typescript() && eat!(p, "extends") {
p.emit_err(p.input.prev_span(), SyntaxError::TS1173);
let (sc, type_params) = p.parse_super_class()?;
if super_class.is_none() {
super_class = Some(sc);
if type_params.is_some() {
super_type_params = type_params;
}
}
}
expect!(p, '{');
let body = p
.with_ctx(Context {
has_super_class: super_class.is_some(),
..p.ctx()
})
.parse_class_body()?;
if p.input.cur().is_none() {
let eof_text = p.input.dump_cur();
p.emit_err(
p.input.cur_span(),
SyntaxError::Expected(&Token::RBrace, eof_text),
);
} else {
expect!(p, '}');
}
let end = last_pos!(p);
Ok((
ident,
Box::new(Class {
span: Span::new(class_start, end),
decorators,
is_abstract: false,
type_params,
super_class,
super_type_params,
body,
implements,
..Default::default()
}),
))
})
}
fn parse_class<T>(
&mut self,
start: BytePos,
class_start: BytePos,
decorators: Vec<Decorator>,
is_abstract: bool,
) -> PResult<T>
where
T: OutputType,
{
let (ident, mut class) = self
.with_ctx(Context {
in_class: true,
..self.ctx()
})
.parse_class_inner(start, class_start, decorators, T::IS_IDENT_REQUIRED)?;
if is_abstract {
class.is_abstract = true
} else {
for member in class.body.iter() {
match member {
ClassMember::ClassProp(ClassProp {
is_abstract: true,
span,
..
})
| ClassMember::Method(ClassMethod {
span,
is_abstract: true,
..
}) => self.emit_err(*span, SyntaxError::TS1244),
_ => (),
}
}
}
match T::finish_class(span!(self, start), ident, class) {
Ok(v) => Ok(v),
Err(kind) => syntax_error!(self, kind),
}
}
fn parse_super_class(&mut self) -> PResult<(Box<Expr>, Option<Box<TsTypeParamInstantiation>>)> {
let super_class = self.parse_lhs_expr()?;
match *super_class {
Expr::TsInstantiation(TsInstantiation {
expr, type_args, ..
}) => Ok((expr, Some(type_args))),
_ => {
// We still need to parse TS type arguments,
// because in some cases "super class" returned by `parse_lhs_expr`
// may not include `TsExprWithTypeArgs`
// but it's a super class with type params, for example, in JSX.
if self.syntax().typescript() && is!(self, '<') {
Ok((super_class, self.parse_ts_type_args().map(Some)?))
} else {
Ok((super_class, None))
}
}
}
}
pub(super) fn parse_decorators(&mut self, allow_export: bool) -> PResult<Vec<Decorator>> {
if !self.syntax().decorators() {
return Ok(Vec::new());
}
trace_cur!(self, parse_decorators);
let mut decorators = Vec::new();
let start = cur_pos!(self);
while is!(self, '@') {
decorators.push(self.parse_decorator()?);
}
if decorators.is_empty() {
return Ok(decorators);
}
if is!(self, "export") {
if !self.ctx().in_class && !self.ctx().in_function && !allow_export {
syntax_error!(self, self.input.cur_span(), SyntaxError::ExportNotAllowed);
}
if !self.ctx().in_class
&& !self.ctx().in_function
&& !self.syntax().decorators_before_export()
{
syntax_error!(self, span!(self, start), SyntaxError::DecoratorOnExport);
}
} else if !is!(self, "class") {
// syntax_error!(self, span!(self, start),
// SyntaxError::InvalidLeadingDecorator)
}
Ok(decorators)
}
fn parse_decorator(&mut self) -> PResult<Decorator> {
let start = cur_pos!(self);
trace_cur!(self, parse_decorator);
assert_and_bump!(self, '@');
let expr = if eat!(self, '(') {
let expr = self.parse_expr()?;
expect!(self, ')');
expr
} else {
let expr = self
.parse_ident(false, false)
.map(Expr::from)
.map(Box::new)?;
self.parse_subscripts(Callee::Expr(expr), false, true)?
};
let expr = self.parse_maybe_decorator_args(expr)?;
Ok(Decorator {
span: span!(self, start),
expr,
})
}
fn parse_maybe_decorator_args(&mut self, expr: Box<Expr>) -> PResult<Box<Expr>> {
let type_args = if self.input.syntax().typescript() && is!(self, '<') {
Some(self.parse_ts_type_args()?)
} else {
None
};
if type_args.is_none() && !is!(self, '(') {
return Ok(expr);
}
let args = self.parse_args(false)?;
Ok(CallExpr {
span: span!(self, expr.span_lo()),
callee: Callee::Expr(expr),
args,
..Default::default()
}
.into())
}
fn parse_class_body(&mut self) -> PResult<Vec<ClassMember>> {
let mut elems = Vec::new();
let mut has_constructor_with_body = false;
while !eof!(self) && !is!(self, '}') {
if eat_exact!(self, ';') {
let span = self.input.prev_span();
elems.push(ClassMember::Empty(EmptyStmt {
span: Span::new(span.lo, span.hi),
}));
continue;
}
let mut p = self.with_ctx(Context {
allow_direct_super: true,
..self.ctx()
});
let elem = p.parse_class_member()?;
if !p.ctx().in_declare {
if let ClassMember::Constructor(Constructor {
body: Some(..),
span,
..
}) = elem
{
if has_constructor_with_body {
p.emit_err(span, SyntaxError::DuplicateConstructor);
}
has_constructor_with_body = true;
}
}
elems.push(elem);
}
Ok(elems)
}
pub(super) fn parse_access_modifier(&mut self) -> PResult<Option<Accessibility>> {
Ok(self
.parse_ts_modifier(&["public", "protected", "private", "in", "out"], false)?
.and_then(|s| match s {
"public" => Some(Accessibility::Public),
"protected" => Some(Accessibility::Protected),
"private" => Some(Accessibility::Private),
other => {
self.emit_err(self.input.prev_span(), SyntaxError::TS1274(other.into()));
None
}
}))
}
fn parse_class_member(&mut self) -> PResult<ClassMember> {
trace_cur!(self, parse_class_member);
let start = cur_pos!(self);
let decorators = self.parse_decorators(false)?;
let declare = self.syntax().typescript() && eat!(self, "declare");
let accessibility = if self.input.syntax().typescript() {
self.parse_access_modifier()?
} else {
None
};
// Allow `private declare`.
let declare = declare || self.syntax().typescript() && eat!(self, "declare");
let declare_token = if declare {
// Handle declare(){}
if self.is_class_method() {
let key = Key::Public(PropName::Ident(IdentName::new(
"declare".into(),
span!(self, start),
)));
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
return self.make_method(
|p| p.parse_unique_formal_params(),
MakeMethodArgs {
start,
accessibility,
decorators,
is_abstract: false,
is_optional,
is_override: false,
is_async: false,
is_generator: false,
static_token: None,
key,
kind: MethodKind::Method,
},
);
} else if self.is_class_property(/* asi */ true)
|| (self.syntax().typescript() && is!(self, '?'))
{
// Property named `declare`
let key = Key::Public(PropName::Ident(IdentName::new(
"declare".into(),
span!(self, start),
)));
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
return self.make_property(
start,
decorators,
accessibility,
key,
false,
None,
is_optional,
false,
false,
false,
false,
);
} else {
Some(span!(self, start))
}
} else {
None
};
let static_token = {
let start = cur_pos!(self);
if eat!(self, "static") {
Some(span!(self, start))
} else {
None
}
};
let accessor_token = if self.syntax().auto_accessors() {
let start = cur_pos!(self);
if eat!(self, "accessor") {
Some(span!(self, start))
} else {
None
}
} else {
None
};
if let Some(accessor_token) = accessor_token {
// Handle accessor(){}
if self.is_class_method() {
let key = Key::Public(PropName::Ident(IdentName::new(
"accessor".into(),
accessor_token,
)));
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
return self.make_method(
|p| p.parse_unique_formal_params(),
MakeMethodArgs {
start,
accessibility,
decorators,
is_abstract: false,
is_optional,
is_override: false,
is_async: false,
is_generator: false,
static_token,
key,
kind: MethodKind::Method,
},
);
} else if self.is_class_property(/* asi */ true)
|| (self.syntax().typescript() && is!(self, '?'))
{
// Property named `accessor`
let key = Key::Public(PropName::Ident(IdentName::new(
"accessor".into(),
accessor_token,
)));
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
let is_static = static_token.is_some();
return self.make_property(
start,
decorators,
accessibility,
key,
is_static,
None,
is_optional,
false,
declare,
false,
false,
);
}
}
if let Some(static_token) = static_token {
// Handle static(){}
if self.is_class_method() {
let key = Key::Public(PropName::Ident(IdentName::new(
"static".into(),
static_token,
)));
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
return self.make_method(
|p| p.parse_unique_formal_params(),
MakeMethodArgs {
start,
accessibility,
decorators,
is_abstract: false,
is_optional,
is_override: false,
is_async: false,
is_generator: false,
static_token: None,
key,
kind: MethodKind::Method,
},
);
} else if self.is_class_property(/* asi */ false)
|| (self.syntax().typescript() && is!(self, '?'))
{
// Property named `static`
// Avoid to parse
// static
// {}
let is_parsing_static_blocks = is!(self, '{');
if !is_parsing_static_blocks {
let key = Key::Public(PropName::Ident(IdentName::new(
"static".into(),
static_token,
)));
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
return self.make_property(
start,
decorators,
accessibility,
key,
false,
accessor_token,
is_optional,
false,
declare,
false,
false,
);
}
} else {
// TODO: error if static contains escape
}
}
self.parse_class_member_with_is_static(
start,
declare_token,
accessibility,
static_token,
accessor_token,
decorators,
)
}
fn parse_static_block(&mut self, start: BytePos) -> PResult<ClassMember> {
let body = self
.with_ctx(Context {
in_static_block: true,
in_class_field: true,
allow_using_decl: true,
..self.ctx()
})
.parse_block(false)?;
let span = span!(self, start);
Ok(StaticBlock { span, body }.into())
}
fn parse_class_member_with_is_static(
&mut self,
start: BytePos,
declare_token: Option<Span>,
accessibility: Option<Accessibility>,
static_token: Option<Span>,
accessor_token: Option<Span>,
decorators: Vec<Decorator>,
) -> PResult<ClassMember> {
let mut is_static = static_token.is_some();
let mut is_abstract = false;
let mut is_override = false;
let mut readonly = None;
let mut modifier_span = None;
let declare = declare_token.is_some();
while let Some(modifier) =
self.parse_ts_modifier(&["abstract", "readonly", "override", "static"], true)?
{
modifier_span = Some(self.input.prev_span());
match modifier {
"abstract" => {
if is_abstract {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1030("abstract".into()),
);
} else if is_override {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1029("abstract".into(), "override".into()),
);
}
is_abstract = true;
}
"override" => {
if is_override {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1030("override".into()),
);
} else if readonly.is_some() {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1029("override".into(), "readonly".into()),
);
} else if declare {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1243("override".into(), "declare".into()),
);
} else if !self.ctx().has_super_class {
self.emit_err(self.input.prev_span(), SyntaxError::TS4112);
}
is_override = true;
}
"readonly" => {
let readonly_span = self.input.prev_span();
if readonly.is_some() {
self.emit_err(readonly_span, SyntaxError::TS1030("readonly".into()));
} else {
readonly = Some(readonly_span);
}
}
"static" => {
if is_override {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1029("static".into(), "override".into()),
);
}
is_static = true;
}
_ => {}
}
}
let accessor_token = accessor_token.or_else(|| {
if self.syntax().auto_accessors() && readonly.is_none() {
let start = cur_pos!(self);
if eat!(self, "accessor") {
Some(span!(self, start))
} else {
None
}
} else {
None
}
});
if is_static && is!(self, '{') {
if let Some(span) = declare_token {
self.emit_err(span, SyntaxError::TS1184);
}
if accessibility.is_some() {
self.emit_err(self.input.cur_span(), SyntaxError::TS1184);
}
return self.parse_static_block(start);
}
if is!(self, "static") && peeked_is!(self, '{') {
// For "readonly", "abstract" and "override"
if let Some(span) = modifier_span {
self.emit_err(span, SyntaxError::TS1184);
}
if let Some(span) = static_token {
self.emit_err(span, SyntaxError::TS1184);
}
bump!(self); // consume "static"
return self.parse_static_block(start);
}
if self.input.syntax().typescript()
&& !is_abstract
&& !is_override
&& accessibility.is_none()
{
let idx = self.try_parse_ts_index_signature(start, readonly.is_some(), is_static)?;
if let Some(idx) = idx {
return Ok(idx.into());
}
}
if eat!(self, '*') {
// generator method
let key = self.parse_class_prop_name()?;
if readonly.is_some() {
self.emit_err(span!(self, start), SyntaxError::ReadOnlyMethod);
}
if is_constructor(&key) {
self.emit_err(span!(self, start), SyntaxError::GeneratorConstructor);
}
return self.make_method(
|p| p.parse_unique_formal_params(),
MakeMethodArgs {
start,
decorators,
is_async: false,
is_generator: true,
accessibility,
is_abstract,
is_override,
is_optional: false,
static_token,
key,
kind: MethodKind::Method,
},
);
}
trace_cur!(self, parse_class_member_with_is_static__normal_class_member);
let key = if readonly.is_some() && is_one_of!(self, '!', ':') {
Key::Public(PropName::Ident(IdentName::new(
"readonly".into(),
readonly.unwrap(),
)))
} else {
self.parse_class_prop_name()?
};
let is_optional = self.input.syntax().typescript() && eat!(self, '?');
if self.is_class_method() {
// handle a(){} / get(){} / set(){} / async(){}
trace_cur!(self, parse_class_member_with_is_static__normal_class_method);
if let Some(token) = declare_token {
self.emit_err(token, SyntaxError::TS1031)
}
if readonly.is_some() {
syntax_error!(self, span!(self, start), SyntaxError::ReadOnlyMethod);
}
let is_constructor = is_constructor(&key);
if is_constructor {
if self.syntax().typescript() && is_override {
self.emit_err(span!(self, start), SyntaxError::TS1089("override".into()));
}
if self.syntax().typescript() && is!(self, '<') {
let start = cur_pos!(self);
if peeked_is!(self, '>') {
assert_and_bump!(self, '<');
let start2 = cur_pos!(self);
assert_and_bump!(self, '>');
self.emit_err(span!(self, start), SyntaxError::TS1098);
self.emit_err(span!(self, start2), SyntaxError::TS1092);
} else {
let type_params = self.try_parse_ts_type_params(false, true)?;
if let Some(type_params) = type_params {
for param in type_params.params {
self.emit_err(param.span(), SyntaxError::TS1092);
}
}
}
}
expect!(self, '(');
let params = self.parse_constructor_params()?;
expect!(self, ')');
if self.syntax().typescript() && is!(self, ':') {
let start = cur_pos!(self);
let type_ann = self.parse_ts_type_ann(true, start)?;
self.emit_err(type_ann.type_ann.span(), SyntaxError::TS1093);
}
let body: Option<_> =
self.parse_fn_body(false, false, false, params.is_simple_parameter_list())?;
if body.is_none() {
for param in params.iter() {
if param.is_ts_param_prop() {
self.emit_err(param.span(), SyntaxError::TS2369)
}
}
}
if self.syntax().typescript() && body.is_none() {
// Declare constructors cannot have assignment pattern in parameters
for p in ¶ms {
// TODO: Search deeply for assignment pattern using a Visitor
let span = match *p {
ParamOrTsParamProp::Param(ref param) => match param.pat {
Pat::Assign(ref p) => Some(p.span()),
_ => None,
},
ParamOrTsParamProp::TsParamProp(TsParamProp {
param: TsParamPropParam::Assign(ref p),
..
}) => Some(p.span()),
_ => None,
};
if let Some(span) = span {
self.emit_err(span, SyntaxError::TS2371)
}
}
}
if let Some(static_token) = static_token {
self.emit_err(static_token, SyntaxError::TS1089("static".into()))
}
if let Some(span) = modifier_span {
if is_abstract {
self.emit_err(span, SyntaxError::TS1242);
}
}
return Ok(ClassMember::Constructor(Constructor {
span: span!(self, start),
accessibility,
key: match key {
Key::Public(key) => key,
_ => unreachable!("is_constructor() returns false for PrivateName"),
},
is_optional,
params,
body,
..Default::default()
}));
} else {
return self.make_method(
|p| p.parse_formal_params(),
MakeMethodArgs {
start,
is_optional,
accessibility,
decorators,
is_abstract,
is_override,
static_token,
kind: MethodKind::Method,
key,
is_async: false,
is_generator: false,
},
);
}
}
let is_next_line_generator = self.input.had_line_break_before_cur() && is!(self, '*');
let getter_or_setter_ident = match key {
// `get\n*` is an uninitialized property named 'get' followed by a generator.
Key::Public(PropName::Ident(ref i))
if (i.sym == "get" || i.sym == "set")
&& !self.is_class_property(/* asi */ false)
&& !is_next_line_generator =>
{
Some(i)
}
_ => None,
};
if getter_or_setter_ident.is_none() && self.is_class_property(/* asi */ true) {
return self.make_property(
start,
decorators,
accessibility,
key,
is_static,
accessor_token,
is_optional,
readonly.is_some(),
declare,
is_abstract,
is_override,
);
}
if match key {
Key::Public(PropName::Ident(ref i)) => i.sym == "async",
_ => false,
} && !self.input.had_line_break_before_cur()
{
// handle async foo(){}
if self.parse_ts_modifier(&["override"], false)?.is_some() {
is_override = true;
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1029("override".into(), "async".into()),
);
}
let is_generator = eat!(self, '*');
let key = self.parse_class_prop_name()?;
if is_constructor(&key) {
syntax_error!(self, key.span(), SyntaxError::AsyncConstructor)
}
if readonly.is_some() {
syntax_error!(self, span!(self, start), SyntaxError::ReadOnlyMethod);
}
// handle async foo(){}
let is_optional = is_optional || self.input.syntax().typescript() && eat!(self, '?');
return self.make_method(
|p| p.parse_unique_formal_params(),
MakeMethodArgs {
start,
static_token,
key,
is_abstract,
accessibility,
is_optional,
is_override,
decorators,
kind: MethodKind::Method,
is_async: true,
is_generator,
},
);
}
if let Some(i) = getter_or_setter_ident {
let key_span = key.span();
// handle get foo(){} / set foo(v){}
let key = self.parse_class_prop_name()?;
if readonly.is_some() {
self.emit_err(key_span, SyntaxError::GetterSetterCannotBeReadonly);
}
if is_constructor(&key) {
self.emit_err(key_span, SyntaxError::ConstructorAccessor);
}
return match &*i.sym {
"get" => self.make_method(
|p| {
let params = p.parse_formal_params()?;
if params.iter().filter(|p| is_not_this(p)).count() != 0 {
p.emit_err(key_span, SyntaxError::GetterParam);
}
Ok(params)
},
MakeMethodArgs {
decorators,
start,
is_abstract,
is_async: false,
is_generator: false,
is_optional,
is_override,
accessibility,
static_token,
key,
kind: MethodKind::Getter,
},
),
"set" => self.make_method(
|p| {
let params = p.parse_formal_params()?;
if params.iter().filter(|p| is_not_this(p)).count() != 1 {
p.emit_err(key_span, SyntaxError::SetterParam);
}
if !params.is_empty() {
if let Pat::Rest(..) = params[0].pat {
p.emit_err(params[0].pat.span(), SyntaxError::RestPatInSetter);
}
}
Ok(params)
},
MakeMethodArgs {
decorators,
start,
is_optional,
is_abstract,
is_override,
is_async: false,
is_generator: false,
accessibility,
static_token,
key,
kind: MethodKind::Setter,
},
),
_ => unreachable!(),
};
}
unexpected!(self, "* for generator, private key, identifier or async")
}
fn make_property(
&mut self,
start: BytePos,
decorators: Vec<Decorator>,
accessibility: Option<Accessibility>,
key: Key,
is_static: bool,
accessor_token: Option<Span>,
is_optional: bool,
readonly: bool,
declare: bool,
is_abstract: bool,
is_override: bool,
) -> PResult<ClassMember> {
if is_constructor(&key) {
syntax_error!(self, key.span(), SyntaxError::PropertyNamedConstructor);
}
if key.is_private() {
if declare {
self.emit_err(
key.span(),
SyntaxError::PrivateNameModifier("declare".into()),
)
}
if is_abstract {
self.emit_err(
key.span(),
SyntaxError::PrivateNameModifier("abstract".into()),
)
}
}
let definite = self.input.syntax().typescript() && !is_optional && eat!(self, '!');
let type_ann = self.try_parse_ts_type_ann()?;
let ctx = Context {
include_in_expr: true,
in_class_field: true,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
let value = if is!(p, '=') {
assert_and_bump!(p, '=');
Some(p.parse_assignment_expr()?)
} else {
None
};
if !eat!(p, ';') {
p.emit_err(p.input.cur_span(), SyntaxError::TS1005);
}
if accessor_token.is_some() {
return Ok(ClassMember::AutoAccessor(AutoAccessor {
span: span!(p, start),
key,
value,
type_ann,
is_static,
decorators,
accessibility,
is_abstract,
is_override,
definite,
}));
}
Ok(match key {
Key::Private(key) => {
let span = span!(p, start);
if accessibility.is_some() {
p.emit_err(span.with_hi(key.span_hi()), SyntaxError::TS18010);
}
PrivateProp {
span: span!(p, start),
key,
value,
is_static,
decorators,
accessibility,
is_optional,
is_override,
readonly,
type_ann,
definite,
ctxt: Default::default(),
}
.into()
}
Key::Public(key) => {
let span = span!(p, start);
if is_abstract && value.is_some() {
p.emit_err(span, SyntaxError::TS1267)
}
ClassProp {
span,
key,
value,
is_static,
decorators,
accessibility,
is_abstract,
is_optional,
is_override,
readonly,
declare,
definite,
type_ann,
}
.into()
}
})
})
}
fn is_class_method(&mut self) -> bool {
is!(self, '(')
|| (self.input.syntax().typescript() && is!(self, '<'))
|| (self.input.syntax().typescript() && is!(self, JSXTagStart))
}
fn is_class_property(&mut self, asi: bool) -> bool {
(self.input.syntax().typescript() && is_one_of!(self, '!', ':'))
|| is_one_of!(self, '=', '}')
|| if asi {
is!(self, ';')
} else {
is_exact!(self, ';')
}
}
fn parse_fn_inner(
&mut self,
_start_of_output_type: Option<BytePos>,
start_of_async: Option<BytePos>,
decorators: Vec<Decorator>,
is_fn_expr: bool,
is_ident_required: bool,
) -> PResult<(Option<Ident>, Box<Function>)> {
let start = start_of_async.unwrap_or_else(|| cur_pos!(self));
assert_and_bump!(self, "function");
let is_async = start_of_async.is_some();
let is_generator = eat!(self, '*');
let ident = if is_fn_expr {
//
self.with_ctx(Context {
in_async: is_async,
in_generator: is_generator,
allow_direct_super: false,
in_class_field: false,
..self.ctx()
})
.parse_maybe_opt_binding_ident(is_ident_required, false)?
} else {
// function declaration does not change context for `BindingIdentifier`.
self.with_ctx(Context {
allow_direct_super: false,
in_class_field: false,
..self.ctx()
})
.parse_maybe_opt_binding_ident(is_ident_required, false)?
}
.map(Ident::from);
self.with_ctx(Context {
allow_direct_super: false,
in_class_field: false,
will_expect_colon_for_cond: false,
..self.ctx()
})
.parse_with(|p| {
let f = p.parse_fn_args_body(
decorators,
start,
|p| p.parse_formal_params(),
is_async,
is_generator,
)?;
if is_fn_expr && f.body.is_none() {
unexpected!(p, "{");
}
Ok((ident, f))
})
}
fn parse_fn<T>(
&mut self,
start_of_output_type: Option<BytePos>,
start_of_async: Option<BytePos>,
decorators: Vec<Decorator>,
) -> PResult<T>
where
T: OutputType,
{
let start = start_of_async.unwrap_or_else(|| cur_pos!(self));
let (ident, f) = self.parse_fn_inner(
start_of_output_type,
start_of_async,
decorators,
T::is_fn_expr(),
T::IS_IDENT_REQUIRED,
)?;
match T::finish_fn(span!(self, start_of_output_type.unwrap_or(start)), ident, f) {
Ok(v) => Ok(v),
Err(kind) => syntax_error!(self, kind),
}
}
/// If `required` is `true`, this never returns `None`.
fn parse_maybe_opt_binding_ident(
&mut self,
required: bool,
disallow_let: bool,
) -> PResult<Option<Ident>> {
if required {
self.parse_binding_ident(disallow_let)
.map(|v| v.id)
.map(Some)
} else {
self.parse_opt_binding_ident(disallow_let)
.map(|v| v.map(|v| v.id))
}
}
/// `parse_args` closure should not eat '(' or ')'.
pub(super) fn parse_fn_args_body<F>(
&mut self,
decorators: Vec<Decorator>,
start: BytePos,
parse_args: F,
is_async: bool,
is_generator: bool,
) -> PResult<Box<Function>>
where
F: FnOnce(&mut Self) -> PResult<Vec<Param>>,
{
trace_cur!(self, parse_fn_args_body);
// let prev_in_generator = self.ctx().in_generator;
let ctx = Context {
in_async: is_async,
in_generator: is_generator,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
let type_params = if p.syntax().typescript() {
p.in_type().parse_with(|p| {
trace_cur!(p, parse_fn_args_body__type_params);
Ok(if is!(p, '<') {
Some(p.parse_ts_type_params(false, true)?)
} else if is!(p, JSXTagStart) {
debug_assert_eq!(
p.input.token_context().current(),
Some(TokenContext::JSXOpeningTag)
);
p.input.token_context_mut().pop();
debug_assert_eq!(
p.input.token_context().current(),
Some(TokenContext::JSXExpr)
);
p.input.token_context_mut().pop();
Some(p.parse_ts_type_params(false, true)?)
} else {
None
})
})?
} else {
None
};
expect!(p, '(');
let arg_ctx = Context {
in_parameters: true,
in_function: false,
in_async: is_async,
in_generator: is_generator,
..p.ctx()
};
let params = p.with_ctx(arg_ctx).parse_with(|p| parse_args(p))?;
expect!(p, ')');
// typescript extension
let return_type = if p.syntax().typescript() && is!(p, ':') {
p.parse_ts_type_or_type_predicate_ann(&tok!(':'))
.map(Some)?
} else {
None
};
let body: Option<_> = p.parse_fn_body(
is_async,
is_generator,
false,
params.is_simple_parameter_list(),
)?;
if p.syntax().typescript() && body.is_none() {
// Declare functions cannot have assignment pattern in parameters
for param in ¶ms {
// TODO: Search deeply for assignment pattern using a Visitor
let span = match ¶m.pat {
Pat::Assign(ref p) => Some(p.span()),
_ => None,
};
if let Some(span) = span {
p.emit_err(span, SyntaxError::TS2371)
}
}
}
Ok(Box::new(Function {
span: span!(p, start),
decorators,
type_params,
params,
body,
is_async,
is_generator,
return_type,
ctxt: Default::default(),
}))
})
}
fn parse_class_prop_name(&mut self) -> PResult<Key> {
if is!(self, '#') {
let name = self.parse_private_name()?;
if name.name == "constructor" {
self.emit_err(name.span, SyntaxError::PrivateConstructor);
}
Ok(Key::Private(name))
} else {
self.parse_prop_name().map(Key::Public)
}
}
pub(super) fn parse_fn_body<T>(
&mut self,
is_async: bool,
is_generator: bool,
is_arrow_function: bool,
is_simple_parameter_list: bool,
) -> PResult<T>
where
Self: FnBodyParser<T>,
{
if self.ctx().in_declare && self.syntax().typescript() && is!(self, '{') {
// self.emit_err(
// self.ctx().span_of_fn_name.expect("we are not in function"),
// SyntaxError::TS1183,
// );
self.emit_err(self.input.cur_span(), SyntaxError::TS1183);
}
let ctx = Context {
in_async: is_async,
in_generator: is_generator,
inside_non_arrow_function_scope: if is_arrow_function {
self.ctx().inside_non_arrow_function_scope
} else {
true
},
in_function: true,
in_static_block: false,
is_break_allowed: false,
is_continue_allowed: false,
..self.ctx()
};
let state = State {
labels: Vec::new(),
..Default::default()
};
self.with_ctx(ctx)
.with_state(state)
.parse_fn_body_inner(is_simple_parameter_list)
}
}
impl<I: Tokens> Parser<I> {
fn make_method<F>(
&mut self,
parse_args: F,
MakeMethodArgs {
start,
accessibility,
is_abstract,
static_token,
decorators,
is_optional,
is_override,
key,
kind,
is_async,
is_generator,
}: MakeMethodArgs,
) -> PResult<ClassMember>
where
F: FnOnce(&mut Self) -> PResult<Vec<Param>>,
{
trace_cur!(self, make_method);
let is_static = static_token.is_some();
let function = self
.with_ctx(Context {
allow_direct_super: true,
in_class_field: false,
..self.ctx()
})
.parse_with(|p| {
p.parse_fn_args_body(decorators, start, parse_args, is_async, is_generator)
})?;
match kind {
MethodKind::Getter | MethodKind::Setter
if self.input.syntax().typescript() && self.input.target() == EsVersion::Es3 =>
{
self.emit_err(key.span(), SyntaxError::TS1056);
}
_ => {}
}
match key {
Key::Private(key) => {
let span = span!(self, start);
if accessibility.is_some() {
self.emit_err(span.with_hi(key.span_hi()), SyntaxError::TS18010);
}
Ok(PrivateMethod {
span,
accessibility,
is_abstract,
is_optional,
is_override,
is_static,
key,
function,
kind,
}
.into())
}
Key::Public(key) => {
let span = span!(self, start);
if is_abstract && function.body.is_some() {
self.emit_err(span, SyntaxError::TS1245)
}
Ok(ClassMethod {
span,
accessibility,
is_abstract,
is_optional,
is_override,
is_static,
key,
function,
kind,
}
.into())
}
}
}
}
trait IsInvalidClassName {
fn invalid_class_name(&self) -> Option<Span>;
}
impl IsInvalidClassName for Ident {
fn invalid_class_name(&self) -> Option<Span> {
match &*self.sym {
"string" | "null" | "number" | "object" | "any" | "unknown" | "boolean" | "bigint"
| "symbol" | "void" | "never" | "intrinsic" => Some(self.span),
_ => None,
}
}
}
impl IsInvalidClassName for Option<Ident> {
fn invalid_class_name(&self) -> Option<Span> {
if let Some(i) = self.as_ref() {
return i.invalid_class_name();
}
None
}
}
trait OutputType: Sized {
const IS_IDENT_REQUIRED: bool;
/// From babel..
///
/// When parsing function expression, the binding identifier is parsed
/// according to the rules inside the function.
/// e.g. (function* yield() {}) is invalid because "yield" is disallowed in
/// generators.
/// This isn't the case with function declarations: function* yield() {} is
/// valid because yield is parsed as if it was outside the generator.
/// Therefore, this.state.inGenerator is set before or after parsing the
/// function id according to the "isStatement" parameter.
fn is_fn_expr() -> bool {
false
}
fn finish_fn(span: Span, ident: Option<Ident>, f: Box<Function>) -> Result<Self, SyntaxError>;
fn finish_class(
span: Span,
ident: Option<Ident>,
class: Box<Class>,
) -> Result<Self, SyntaxError>;
}
impl OutputType for Box<Expr> {
const IS_IDENT_REQUIRED: bool = false;
fn is_fn_expr() -> bool {
true
}
fn finish_fn(
_span: Span,
ident: Option<Ident>,
function: Box<Function>,
) -> Result<Self, SyntaxError> {
Ok(FnExpr { ident, function }.into())
}
fn finish_class(
_span: Span,
ident: Option<Ident>,
class: Box<Class>,
) -> Result<Self, SyntaxError> {
Ok(ClassExpr { ident, class }.into())
}
}
impl OutputType for ExportDefaultDecl {
const IS_IDENT_REQUIRED: bool = false;
fn finish_fn(
span: Span,
ident: Option<Ident>,
function: Box<Function>,
) -> Result<Self, SyntaxError> {
Ok(ExportDefaultDecl {
span,
decl: DefaultDecl::Fn(FnExpr { ident, function }),
})
}
fn finish_class(
span: Span,
ident: Option<Ident>,
class: Box<Class>,
) -> Result<Self, SyntaxError> {
Ok(ExportDefaultDecl {
span,
decl: DefaultDecl::Class(ClassExpr { ident, class }),
})
}
}
impl OutputType for Decl {
const IS_IDENT_REQUIRED: bool = true;
fn finish_fn(
_span: Span,
ident: Option<Ident>,
function: Box<Function>,
) -> Result<Self, SyntaxError> {
let ident = ident.ok_or(SyntaxError::ExpectedIdent)?;
Ok(FnDecl {
declare: false,
ident,
function,
}
.into())
}
fn finish_class(_: Span, ident: Option<Ident>, class: Box<Class>) -> Result<Self, SyntaxError> {
let ident = ident.ok_or(SyntaxError::ExpectedIdent)?;
Ok(ClassDecl {
declare: false,
ident,
class,
}
.into())
}
}
pub(super) trait FnBodyParser<Body> {
fn parse_fn_body_inner(&mut self, is_simple_parameter_list: bool) -> PResult<Body>;
}
fn has_use_strict(block: &BlockStmt) -> Option<Span> {
block
.stmts
.iter()
.take_while(|s| s.can_precede_directive())
.find_map(|s| {
if s.is_use_strict() {
Some(s.span())
} else {
None
}
})
}
impl<I: Tokens> FnBodyParser<Box<BlockStmtOrExpr>> for Parser<I> {
fn parse_fn_body_inner(
&mut self,
is_simple_parameter_list: bool,
) -> PResult<Box<BlockStmtOrExpr>> {
if is!(self, '{') {
self.parse_block(false)
.map(|block_stmt| {
if !is_simple_parameter_list {
if let Some(span) = has_use_strict(&block_stmt) {
self.emit_err(span, SyntaxError::IllegalLanguageModeDirective);
}
}
BlockStmtOrExpr::BlockStmt(block_stmt)
})
.map(Box::new)
} else {
self.parse_assignment_expr()
.map(BlockStmtOrExpr::Expr)
.map(Box::new)
}
}
}
impl<I: Tokens> FnBodyParser<Option<BlockStmt>> for Parser<I> {
fn parse_fn_body_inner(
&mut self,
is_simple_parameter_list: bool,
) -> PResult<Option<BlockStmt>> {
// allow omitting body and allow placing `{` on next line
if self.input.syntax().typescript() && !is!(self, '{') && eat!(self, ';') {
return Ok(None);
}
let block = self.include_in_expr(true).parse_block(true);
block.map(|block_stmt| {
if !is_simple_parameter_list {
if let Some(span) = has_use_strict(&block_stmt) {
self.emit_err(span, SyntaxError::IllegalLanguageModeDirective);
}
}
Some(block_stmt)
})
}
}
pub(super) trait IsSimpleParameterList {
fn is_simple_parameter_list(&self) -> bool;
}
impl IsSimpleParameterList for Vec<Param> {
fn is_simple_parameter_list(&self) -> bool {
self.iter().all(|param| matches!(param.pat, Pat::Ident(_)))
}
}
impl IsSimpleParameterList for Vec<Pat> {
fn is_simple_parameter_list(&self) -> bool {
self.iter().all(|pat| matches!(pat, Pat::Ident(_)))
}
}
impl IsSimpleParameterList for Vec<ParamOrTsParamProp> {
fn is_simple_parameter_list(&self) -> bool {
self.iter().all(|param| {
matches!(
param,
ParamOrTsParamProp::TsParamProp(..)
| ParamOrTsParamProp::Param(Param {
pat: Pat::Ident(_),
..
})
)
})
}
}
fn is_constructor(key: &Key) -> bool {
matches!(
&key,
Key::Public(PropName::Ident(IdentName {
sym: constructor,
..
})) | Key::Public(PropName::Str(Str {
value: constructor,
..
})) if &**constructor == "constructor"
)
}
pub(crate) fn is_not_this(p: &Param) -> bool {
!matches!(
&p.pat,
Pat::Ident(BindingIdent {
id: Ident{ sym: this, .. },
..
})if &**this == "this"
)
}
struct MakeMethodArgs {
start: BytePos,
accessibility: Option<Accessibility>,
is_abstract: bool,
static_token: Option<Span>,
decorators: Vec<Decorator>,
is_optional: bool,
is_override: bool,
key: Key,
kind: MethodKind,
is_async: bool,
is_generator: bool,
}
#[cfg(test)]
#[allow(unused)]
mod tests {
use swc_common::DUMMY_SP as span;
use swc_ecma_visit::assert_eq_ignore_span;
use super::*;
fn lhs(s: &'static str) -> Box<Expr> {
test_parser(s, Syntax::default(), |p| p.parse_lhs_expr())
}
fn expr(s: &'static str) -> Box<Expr> {
test_parser(s, Syntax::default(), |p| p.parse_expr())
}
#[test]
fn class_expr() {
assert_eq_ignore_span!(
expr("(class extends a {})"),
Box::new(Expr::Paren(ParenExpr {
span,
expr: Box::new(Expr::Class(ClassExpr {
ident: None,
class: Box::new(Class {
decorators: Vec::new(),
span,
body: Vec::new(),
super_class: Some(expr("a")),
implements: Vec::new(),
is_abstract: false,
..Default::default()
}),
})),
}))
);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/expr.rs | Rust | use either::Either;
use rustc_hash::FxHashMap;
use swc_common::{ast_node, util::take::Take, Spanned};
use super::{pat::PatType, util::ExprExt, *};
use crate::{lexer::TokenContext, parser::class_and_fn::IsSimpleParameterList};
mod ops;
#[cfg(test)]
mod tests;
mod verifier;
impl<I: Tokens> Parser<I> {
pub fn parse_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_expr);
let _tracing = debug_tracing!(self, "parse_expr");
let expr = self.parse_assignment_expr()?;
let start = expr.span_lo();
if is!(self, ',') {
let mut exprs = vec![expr];
while eat!(self, ',') {
exprs.push(self.parse_assignment_expr()?);
}
return Ok(SeqExpr {
span: span!(self, start),
exprs,
}
.into());
}
Ok(expr)
}
///`parseMaybeAssign` (overridden)
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_assignment_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_assignment_expr);
if self.input.syntax().typescript() && is!(self, JSXTagStart) {
// Note: When the JSX plugin is on, type assertions (`<T> x`) aren't valid
// syntax.
let cur_context = self.input.token_context().current();
debug_assert_eq!(cur_context, Some(TokenContext::JSXOpeningTag));
// Only time j_oTag is pushed is right after j_expr.
debug_assert_eq!(
self.input.token_context().0[self.input.token_context().len() - 2],
TokenContext::JSXExpr
);
let res = self.try_parse_ts(|p| p.parse_assignment_expr_base().map(Some));
if let Some(res) = res {
return Ok(res);
} else {
debug_assert_eq!(
self.input.token_context().current(),
Some(TokenContext::JSXOpeningTag)
);
self.input.token_context_mut().pop();
debug_assert_eq!(
self.input.token_context().current(),
Some(TokenContext::JSXExpr)
);
self.input.token_context_mut().pop();
}
}
self.parse_assignment_expr_base()
}
/// Parse an assignment expression. This includes applications of
/// operators like `+=`.
///
/// `parseMaybeAssign`
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
fn parse_assignment_expr_base(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_assignment_expr_base);
let start = self.input.cur_span();
if self.input.syntax().typescript()
&& (is_one_of!(self, '<', JSXTagStart))
&& (peeked_is!(self, IdentName) || peeked_is!(self, JSXName))
{
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
let res = self.with_ctx(ctx).try_parse_ts(|p| {
if is!(p, JSXTagStart) {
if let Some(TokenContext::JSXOpeningTag) = p.input.token_context().current() {
p.input.token_context_mut().pop();
debug_assert_eq!(
p.input.token_context().current(),
Some(TokenContext::JSXExpr)
);
p.input.token_context_mut().pop();
}
}
let type_parameters = p.parse_ts_type_params(false, true)?;
let mut arrow = p.parse_assignment_expr_base()?;
match *arrow {
Expr::Arrow(ArrowExpr {
ref mut span,
ref mut type_params,
..
}) => {
*span = Span::new(type_parameters.span.lo, span.hi);
*type_params = Some(type_parameters);
}
_ => unexpected!(p, "("),
}
Ok(Some(arrow))
});
if let Some(res) = res {
if self.input.syntax().disallow_ambiguous_jsx_like() {
self.emit_err(start, SyntaxError::ReservedArrowTypeParam);
}
return Ok(res);
}
}
if self.ctx().in_generator && is!(self, "yield") {
return self.parse_yield_expr();
}
self.state.potential_arrow_start = match *cur!(self, true) {
Word(Word::Ident(..)) | tok!('(') | tok!("yield") => Some(cur_pos!(self)),
_ => None,
};
let start = cur_pos!(self);
// Try to parse conditional expression.
let cond = self.parse_cond_expr()?;
return_if_arrow!(self, cond);
match *cond {
// if cond is conditional expression but not left-hand-side expression,
// just return it.
Expr::Cond(..) | Expr::Bin(..) | Expr::Unary(..) | Expr::Update(..) => return Ok(cond),
_ => {}
}
self.finish_assignment_expr(start, cond)
}
fn finish_assignment_expr(&mut self, start: BytePos, cond: Box<Expr>) -> PResult<Box<Expr>> {
trace_cur!(self, finish_assignment_expr);
match self.input.cur() {
Some(&Token::AssignOp(op)) => {
let left = if op == AssignOp::Assign {
match AssignTarget::try_from(
self.reparse_expr_as_pat(PatType::AssignPat, cond)?,
) {
Ok(pat) => pat,
Err(expr) => {
syntax_error!(self, expr.span(), SyntaxError::InvalidAssignTarget)
}
}
} else {
// It is an early Reference Error if IsValidSimpleAssignmentTarget of
// LeftHandSideExpression is false.
if !cond.is_valid_simple_assignment_target(self.ctx().strict) {
if self.input.syntax().typescript() {
self.emit_err(cond.span(), SyntaxError::TS2406);
} else {
self.emit_err(cond.span(), SyntaxError::NotSimpleAssign)
}
}
if self.input.syntax().typescript()
&& cond
.as_ident()
.map(|i| i.is_reserved_in_strict_bind())
.unwrap_or(false)
{
self.emit_strict_mode_err(cond.span(), SyntaxError::TS1100);
}
// TODO
match AssignTarget::try_from(cond) {
Ok(v) => v,
Err(v) => {
syntax_error!(self, v.span(), SyntaxError::InvalidAssignTarget);
}
}
};
bump!(self);
let right = self.parse_assignment_expr()?;
Ok(AssignExpr {
span: span!(self, start),
op,
// TODO:
left,
right,
}
.into())
}
_ => Ok(cond),
}
}
/// Spec: 'ConditionalExpression'
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
fn parse_cond_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_cond_expr);
let start = cur_pos!(self);
let test = self.parse_bin_expr()?;
return_if_arrow!(self, test);
if eat!(self, '?') {
let ctx = Context {
in_cond_expr: true,
will_expect_colon_for_cond: true,
include_in_expr: true,
..self.ctx()
};
let cons = self.with_ctx(ctx).parse_assignment_expr()?;
expect!(self, ':');
let ctx = Context {
in_cond_expr: true,
will_expect_colon_for_cond: false,
..self.ctx()
};
let alt = self.with_ctx(ctx).parse_assignment_expr()?;
let span = Span::new(start, alt.span_hi());
Ok(CondExpr {
span,
test,
cons,
alt,
}
.into())
} else {
Ok(test)
}
}
/// Parse a primary expression or arrow function
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_primary_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_primary_expr);
let _ = self.input.cur();
let start = cur_pos!(self);
let can_be_arrow = self
.state
.potential_arrow_start
.map(|s| s == start)
.unwrap_or(false);
if let Some(tok) = self.input.cur() {
match tok {
tok!("this") => {
self.input.bump();
return Ok(ThisExpr {
span: span!(self, start),
}
.into());
}
tok!("async") => {
if peeked_is!(self, "function")
&& !self.input.has_linebreak_between_cur_and_peeked()
{
// handle `async function` expression
return self.parse_async_fn_expr();
}
if can_be_arrow && self.input.syntax().typescript() && peeked_is!(self, '<') {
// try parsing `async<T>() => {}`
if let Some(res) = self.try_parse_ts(|p| {
let start = cur_pos!(p);
assert_and_bump!(p, "async");
p.try_parse_ts_generic_async_arrow_fn(start)
}) {
return Ok(res.into());
}
}
if can_be_arrow
&& peeked_is!(self, '(')
&& !self.input.has_linebreak_between_cur_and_peeked()
{
expect!(self, "async");
let async_span = self.input.prev_span();
return self.parse_paren_expr_or_arrow_fn(can_be_arrow, Some(async_span));
}
}
tok!('[') => {
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
return self.with_ctx(ctx).parse_array_lit();
}
tok!('{') => {
return self.parse_object::<Expr>().map(Box::new);
}
// Handle FunctionExpression and GeneratorExpression
tok!("function") => {
return self.parse_fn_expr();
}
// Literals
tok!("null")
| tok!("true")
| tok!("false")
| Token::Num { .. }
| Token::BigInt { .. }
| Token::Str { .. } => {
return Ok(self.parse_lit()?.into());
}
// Regexp
tok!('/') | tok!("/=") => {
bump!(self);
self.input.set_next_regexp(Some(start));
if let Some(Token::Regex(..)) = self.input.cur() {
self.input.set_next_regexp(None);
match bump!(self) {
Token::Regex(exp, flags) => {
let span = span!(self, start);
let mut flags_count = flags.chars().fold(
FxHashMap::<char, usize>::default(),
|mut map, flag| {
let key = match flag {
// https://tc39.es/ecma262/#sec-isvalidregularexpressionliteral
'd' | 'g' | 'i' | 'm' | 's' | 'u' | 'v' | 'y' => flag,
_ => '\u{0000}', // special marker for unknown flags
};
map.entry(key).and_modify(|count| *count += 1).or_insert(1);
map
},
);
if flags_count.remove(&'\u{0000}').is_some() {
self.emit_err(span, SyntaxError::UnknownRegExpFlags);
}
if let Some((flag, _)) =
flags_count.iter().find(|(_, count)| **count > 1)
{
self.emit_err(span, SyntaxError::DuplicatedRegExpFlags(*flag));
}
return Ok(Lit::Regex(Regex { span, exp, flags }).into());
}
_ => unreachable!(),
}
}
}
tok!('`') => {
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
// parse template literal
return Ok(self.with_ctx(ctx).parse_tpl(false)?.into());
}
tok!('(') => {
return self.parse_paren_expr_or_arrow_fn(can_be_arrow, None);
}
_ => {}
}
}
let decorators = self.parse_decorators(false)?;
if is!(self, "class") {
return self.parse_class_expr(start, decorators);
}
if is!(self, "let")
|| (self.input.syntax().typescript() && is_one_of!(self, IdentRef, "await"))
|| is!(self, IdentRef)
{
let ctx = self.ctx();
let id = self.parse_ident(!ctx.in_generator, !ctx.in_async)?;
if id.is_reserved_in_strict_mode(self.ctx().module && !self.ctx().in_declare) {
self.emit_strict_mode_err(
self.input.prev_span(),
SyntaxError::InvalidIdentInStrict(id.sym.clone()),
);
}
if can_be_arrow
&& id.sym == "async"
&& !self.input.had_line_break_before_cur()
&& is!(self, BindingIdent)
{
// see https://github.com/tc39/ecma262/issues/2034
// ```js
// for(async of
// for(async of x);
// for(async of =>{};;);
// ```
if ctx.expr_ctx.for_loop_init && is!(self, "of") && !peeked_is!(self, "=>") {
// ```spec https://tc39.es/ecma262/#prod-ForInOfStatement
// for ( [lookahead ∉ { let, async of }] LeftHandSideExpression[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return]
// [+Await] for await ( [lookahead ≠ let] LeftHandSideExpression[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return]
// ```
if !ctx.expr_ctx.for_await_loop_init {
self.emit_err(self.input.prev_span(), SyntaxError::TS1106);
}
return Ok(id.into());
}
let ident = self.parse_binding_ident(false)?;
if self.input.syntax().typescript() && ident.sym == "as" && !is!(self, "=>") {
// async as type
let type_ann = self.in_type().parse_with(|p| p.parse_ts_type())?;
return Ok(TsAsExpr {
span: span!(self, start),
expr: Box::new(id.into()),
type_ann,
}
.into());
}
// async a => body
let arg = ident.into();
let params = vec![arg];
expect!(self, "=>");
let body =
self.parse_fn_body(true, false, true, params.is_simple_parameter_list())?;
return Ok(ArrowExpr {
span: span!(self, start),
body,
params,
is_async: true,
is_generator: false,
..Default::default()
}
.into());
} else if can_be_arrow && !self.input.had_line_break_before_cur() && eat!(self, "=>") {
if self.ctx().strict && id.is_reserved_in_strict_bind() {
self.emit_strict_mode_err(id.span, SyntaxError::EvalAndArgumentsInStrict)
}
let params = vec![id.into()];
let body =
self.parse_fn_body(false, false, true, params.is_simple_parameter_list())?;
return Ok(ArrowExpr {
span: span!(self, start),
body,
params,
is_async: false,
is_generator: false,
..Default::default()
}
.into());
} else {
return Ok(id.into());
}
}
if eat!(self, '#') {
let id = self.parse_ident_name()?;
return Ok(PrivateName {
span: span!(self, start),
name: id.sym,
}
.into());
}
syntax_error!(self, self.input.cur_span(), SyntaxError::TS1109)
}
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
fn parse_array_lit(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_array_lit);
let start = cur_pos!(self);
assert_and_bump!(self, '[');
let mut elems = Vec::new();
while !eof!(self) && !is!(self, ']') {
if is!(self, ',') {
expect!(self, ',');
elems.push(None);
continue;
}
elems.push(
self.include_in_expr(true)
.parse_expr_or_spread()
.map(Some)?,
);
if !is!(self, ']') {
expect!(self, ',');
if is!(self, ']') {
self.state
.trailing_commas
.insert(start, self.input.prev_span());
}
}
}
expect!(self, ']');
let span = span!(self, start);
Ok(ArrayLit { span, elems }.into())
}
#[allow(dead_code)]
fn parse_member_expr(&mut self) -> PResult<Box<Expr>> {
self.parse_member_expr_or_new_expr(false)
}
/// `is_new_expr`: true iff we are parsing production 'NewExpression'.
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
fn parse_member_expr_or_new_expr(&mut self, is_new_expr: bool) -> PResult<Box<Expr>> {
let ctx = Context {
should_not_lex_lt_or_gt_as_type: true,
..self.ctx()
};
self.with_ctx(ctx)
.parse_member_expr_or_new_expr_inner(is_new_expr)
}
fn parse_member_expr_or_new_expr_inner(&mut self, is_new_expr: bool) -> PResult<Box<Expr>> {
trace_cur!(self, parse_member_expr_or_new_expr);
let start = cur_pos!(self);
if eat!(self, "new") {
if eat!(self, '.') {
if eat!(self, "target") {
let span = span!(self, start);
let expr = MetaPropExpr {
span,
kind: MetaPropKind::NewTarget,
}
.into();
let ctx = self.ctx();
if (!ctx.inside_non_arrow_function_scope) && !ctx.in_parameters && !ctx.in_class
{
self.emit_err(span, SyntaxError::InvalidNewTarget);
}
return self.parse_subscripts(Callee::Expr(expr), true, false);
}
unexpected!(self, "target")
}
// 'NewExpression' allows new call without paren.
let callee = self.parse_member_expr_or_new_expr(is_new_expr)?;
return_if_arrow!(self, callee);
if is_new_expr {
match *callee {
Expr::OptChain(OptChainExpr {
span,
optional: true,
..
}) => {
syntax_error!(self, span, SyntaxError::OptChainCannotFollowConstructorCall)
}
Expr::Member(MemberExpr { ref obj, .. }) => {
if let Expr::OptChain(OptChainExpr {
span,
optional: true,
..
}) = **obj
{
syntax_error!(
self,
span,
SyntaxError::OptChainCannotFollowConstructorCall
)
}
}
_ => {}
}
}
let type_args = if self.input.syntax().typescript() && is_one_of!(self, '<', "<<") {
self.try_parse_ts(|p| {
let ctx = Context {
should_not_lex_lt_or_gt_as_type: false,
..p.ctx()
};
let args = p.with_ctx(ctx).parse_ts_type_args()?;
if !is!(p, '(') {
// This will fail
expect!(p, '(');
}
Ok(Some(args))
})
} else {
None
};
if !is_new_expr || is!(self, '(') {
// Parsed with 'MemberExpression' production.
let args = self.parse_args(false).map(Some)?;
let new_expr = Callee::Expr(
NewExpr {
span: span!(self, start),
callee,
args,
type_args,
..Default::default()
}
.into(),
);
// We should parse subscripts for MemberExpression.
// Because it's left recursive.
return self.parse_subscripts(new_expr, true, false);
}
// Parsed with 'NewExpression' production.
return Ok(NewExpr {
span: span!(self, start),
callee,
args: None,
type_args,
..Default::default()
}
.into());
}
if eat!(self, "super") {
let base = Callee::Super(Super {
span: span!(self, start),
});
return self.parse_subscripts(base, true, false);
}
if eat!(self, "import") {
return self.parse_dynamic_import_or_import_meta(start, true);
}
let obj = self.parse_primary_expr()?;
return_if_arrow!(self, obj);
let type_args = if self.syntax().typescript() && is!(self, '<') {
self.try_parse_ts_type_args()
} else {
None
};
let obj = if let Some(type_args) = type_args {
trace_cur!(self, parse_member_expr_or_new_expr__with_type_args);
TsInstantiation {
expr: obj,
type_args,
span: span!(self, start),
}
.into()
} else {
obj
};
self.parse_subscripts(Callee::Expr(obj), true, false)
}
/// Parse `NewExpression`.
/// This includes `MemberExpression`.
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_new_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_new_expr);
self.parse_member_expr_or_new_expr(true)
}
/// Parse `Arguments[Yield, Await]`
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_args(&mut self, is_dynamic_import: bool) -> PResult<Vec<ExprOrSpread>> {
trace_cur!(self, parse_args);
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
let start = cur_pos!(p);
expect!(p, '(');
let mut first = true;
let mut expr_or_spreads = Vec::with_capacity(2);
while !eof!(p) && !is!(p, ')') {
if first {
first = false;
} else {
expect!(p, ',');
// Handle trailing comma.
if is!(p, ')') {
if is_dynamic_import && !p.input.syntax().import_attributes() {
syntax_error!(
p,
span!(p, start),
SyntaxError::TrailingCommaInsideImport
)
}
break;
}
}
expr_or_spreads.push(p.include_in_expr(true).parse_expr_or_spread()?);
}
expect!(p, ')');
Ok(expr_or_spreads)
})
}
/// AssignmentExpression[+In, ?Yield, ?Await]
/// ...AssignmentExpression[+In, ?Yield, ?Await]
pub(super) fn parse_expr_or_spread(&mut self) -> PResult<ExprOrSpread> {
trace_cur!(self, parse_expr_or_spread);
let start = cur_pos!(self);
if eat!(self, "...") {
let spread_span = span!(self, start);
let spread = Some(spread_span);
self.include_in_expr(true)
.parse_assignment_expr()
.map_err(|err| {
Error::new(
err.span(),
SyntaxError::WithLabel {
inner: Box::new(err),
span: spread_span,
note: "An expression should follow '...'",
},
)
})
.map(|expr| ExprOrSpread { spread, expr })
} else {
self.parse_assignment_expr()
.map(|expr| ExprOrSpread { spread: None, expr })
}
}
/// Parse paren expression or arrow function expression.
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
fn parse_paren_expr_or_arrow_fn(
&mut self,
can_be_arrow: bool,
async_span: Option<Span>,
) -> PResult<Box<Expr>> {
trace_cur!(self, parse_paren_expr_or_arrow_fn);
let expr_start = async_span.map(|x| x.lo()).unwrap_or_else(|| cur_pos!(self));
// At this point, we can't know if it's parenthesized
// expression or head of arrow function.
// But as all patterns of javascript is subset of
// expressions, we can parse both as expression.
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
let (paren_items, trailing_comma) = self
.with_ctx(ctx)
.include_in_expr(true)
.parse_args_or_pats()?;
let has_pattern = paren_items
.iter()
.any(|item| matches!(item, AssignTargetOrSpread::Pat(..)));
let will_expect_colon_for_cond = self.ctx().will_expect_colon_for_cond;
// This is slow path. We handle arrow in conditional expression.
if self.syntax().typescript() && self.ctx().in_cond_expr && is!(self, ':') {
// TODO: Remove clone
let items_ref = &paren_items;
if let Some(expr) = self.try_parse_ts(|p| {
let return_type = p.parse_ts_type_or_type_predicate_ann(&tok!(':'))?;
expect!(p, "=>");
let params: Vec<Pat> = p
.parse_paren_items_as_params(items_ref.clone(), trailing_comma)?
.into_iter()
.collect();
let body: Box<BlockStmtOrExpr> = p.parse_fn_body(
async_span.is_some(),
false,
true,
params.is_simple_parameter_list(),
)?;
if will_expect_colon_for_cond && !is!(p, ':') {
trace_cur!(p, parse_arrow_in_cond__fail);
unexpected!(p, "fail")
}
Ok(Some(
ArrowExpr {
span: span!(p, expr_start),
is_async: async_span.is_some(),
is_generator: false,
params,
body,
return_type: Some(return_type),
..Default::default()
}
.into(),
))
}) {
return Ok(expr);
}
}
let return_type = if !self.ctx().will_expect_colon_for_cond
&& self.input.syntax().typescript()
&& is!(self, ':')
{
self.try_parse_ts(|p| {
let return_type = p.parse_ts_type_or_type_predicate_ann(&tok!(':'))?;
if !is!(p, "=>") {
unexpected!(p, "fail")
}
Ok(Some(return_type))
})
} else {
None
};
// we parse arrow function at here, to handle it efficiently.
if has_pattern || return_type.is_some() || is!(self, "=>") {
if self.input.had_line_break_before_cur() {
syntax_error!(
self,
span!(self, expr_start),
SyntaxError::LineBreakBeforeArrow
);
}
if !can_be_arrow {
syntax_error!(self, span!(self, expr_start), SyntaxError::ArrowNotAllowed);
}
expect!(self, "=>");
let params: Vec<Pat> = self
.parse_paren_items_as_params(paren_items, trailing_comma)?
.into_iter()
.collect();
let body: Box<BlockStmtOrExpr> = self.parse_fn_body(
async_span.is_some(),
false,
true,
params.is_simple_parameter_list(),
)?;
let arrow_expr = ArrowExpr {
span: span!(self, expr_start),
is_async: async_span.is_some(),
is_generator: false,
params,
body,
return_type,
..Default::default()
};
if let BlockStmtOrExpr::BlockStmt(..) = &*arrow_expr.body {
if let Some(&Token::BinOp(..)) = self.input.cur() {
// ) is required
self.emit_err(self.input.cur_span(), SyntaxError::TS1005);
let errorred_expr =
self.parse_bin_op_recursively(Box::new(arrow_expr.into()), 0)?;
if !is!(self, ';') {
// ; is required
self.emit_err(self.input.cur_span(), SyntaxError::TS1005);
}
return Ok(errorred_expr);
}
}
return Ok(arrow_expr.into());
} else {
// If there's no arrow function, we have to check there's no
// AssignProp in lhs to check against assignment in object literals
// like (a, {b = 1});
for expr_or_spread in paren_items.iter() {
if let AssignTargetOrSpread::ExprOrSpread(e) = expr_or_spread {
if let Expr::Object(o) = &*e.expr {
for p in o.props.iter() {
if let PropOrSpread::Prop(prop) = p {
if let Prop::Assign(..) = **prop {
self.emit_err(prop.span(), SyntaxError::AssignProperty);
}
}
}
}
}
}
}
let expr_or_spreads = paren_items
.into_iter()
.map(|item| -> PResult<_> {
match item {
AssignTargetOrSpread::ExprOrSpread(e) => Ok(e),
_ => syntax_error!(self, item.span(), SyntaxError::InvalidExpr),
}
})
.collect::<Result<Vec<_>, _>>()?;
if let Some(async_span) = async_span {
// It's a call expression
return Ok(CallExpr {
span: span!(self, async_span.lo()),
callee: Callee::Expr(Box::new(
Ident::new_no_ctxt("async".into(), async_span).into(),
)),
args: expr_or_spreads,
..Default::default()
}
.into());
}
// It was not head of arrow function.
if expr_or_spreads.is_empty() {
syntax_error!(
self,
Span::new(expr_start, last_pos!(self),),
SyntaxError::EmptyParenExpr
);
}
// TODO: Verify that invalid expression like {a = 1} does not exists.
// ParenthesizedExpression cannot contain spread.
if expr_or_spreads.len() == 1 {
let expr = match expr_or_spreads.into_iter().next().unwrap() {
ExprOrSpread {
spread: Some(..),
ref expr,
} => syntax_error!(self, expr.span(), SyntaxError::SpreadInParenExpr),
ExprOrSpread { expr, .. } => expr,
};
Ok(ParenExpr {
span: span!(self, expr_start),
expr,
}
.into())
} else {
debug_assert!(expr_or_spreads.len() >= 2);
let mut exprs = Vec::with_capacity(expr_or_spreads.len());
for expr in expr_or_spreads {
match expr {
ExprOrSpread {
spread: Some(..),
ref expr,
} => syntax_error!(self, expr.span(), SyntaxError::SpreadInParenExpr),
ExprOrSpread { expr, .. } => exprs.push(expr),
}
}
debug_assert!(exprs.len() >= 2);
// span of sequence expression should not include '(', ')'
let seq_expr = SeqExpr {
span: Span::new(
exprs.first().unwrap().span_lo(),
exprs.last().unwrap().span_hi(),
),
exprs,
}
.into();
Ok(ParenExpr {
span: span!(self, expr_start),
expr: seq_expr,
}
.into())
}
}
fn parse_tpl_elements(
&mut self,
is_tagged_tpl: bool,
) -> PResult<(Vec<Box<Expr>>, Vec<TplElement>)> {
trace_cur!(self, parse_tpl_elements);
let mut exprs = Vec::new();
let cur_elem = self.parse_tpl_element(is_tagged_tpl)?;
let mut is_tail = cur_elem.tail;
let mut quasis = vec![cur_elem];
while !is_tail {
expect!(self, "${");
exprs.push(self.include_in_expr(true).parse_expr()?);
expect!(self, '}');
let elem = self.parse_tpl_element(is_tagged_tpl)?;
is_tail = elem.tail;
quasis.push(elem);
}
Ok((exprs, quasis))
}
fn parse_tagged_tpl(
&mut self,
tag: Box<Expr>,
type_params: Option<Box<TsTypeParamInstantiation>>,
) -> PResult<TaggedTpl> {
let tagged_tpl_start = tag.span_lo();
trace_cur!(self, parse_tagged_tpl);
let tpl = Box::new(self.parse_tpl(true)?);
let span = span!(self, tagged_tpl_start);
if tag.is_opt_chain() {
self.emit_err(span, SyntaxError::TaggedTplInOptChain);
}
Ok(TaggedTpl {
span,
tag,
type_params,
tpl,
..Default::default()
})
}
pub(super) fn parse_tpl(&mut self, is_tagged_tpl: bool) -> PResult<Tpl> {
trace_cur!(self, parse_tpl);
let start = cur_pos!(self);
assert_and_bump!(self, '`');
let (exprs, quasis) = self.parse_tpl_elements(is_tagged_tpl)?;
expect!(self, '`');
let span = span!(self, start);
Ok(Tpl {
span,
exprs,
quasis,
})
}
pub(super) fn parse_tpl_element(&mut self, is_tagged_tpl: bool) -> PResult<TplElement> {
let start = cur_pos!(self);
let (raw, cooked) = match *cur!(self, true) {
Token::Template { .. } => match bump!(self) {
Token::Template { raw, cooked, .. } => match cooked {
Ok(cooked) => (raw, Some(cooked)),
Err(err) => {
if is_tagged_tpl {
(raw, None)
} else {
return Err(err);
}
}
},
_ => unreachable!(),
},
_ => unexpected!(self, "template token"),
};
let tail = is!(self, '`');
Ok(TplElement {
span: span!(self, start),
raw,
tail,
cooked,
})
}
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_subscripts(
&mut self,
mut obj: Callee,
no_call: bool,
no_computed_member: bool,
) -> PResult<Box<Expr>> {
let start = obj.span().lo;
loop {
obj = match self.parse_subscript(start, obj, no_call, no_computed_member)? {
(expr, false) => return Ok(expr),
(expr, true) => Callee::Expr(expr),
}
}
}
/// returned bool is true if this method should be called again.
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
fn parse_subscript(
&mut self,
start: BytePos,
mut obj: Callee,
no_call: bool,
no_computed_member: bool,
) -> PResult<(Box<Expr>, bool)> {
trace_cur!(self, parse_subscript);
let _ = cur!(self, false);
if self.input.syntax().typescript() {
if !self.input.had_line_break_before_cur() && is!(self, '!') {
self.input.set_expr_allowed(false);
assert_and_bump!(self, '!');
let expr = match obj {
Callee::Super(..) => {
syntax_error!(
self,
self.input.cur_span(),
SyntaxError::TsNonNullAssertionNotAllowed("super".into())
)
}
Callee::Import(..) => {
syntax_error!(
self,
self.input.cur_span(),
SyntaxError::TsNonNullAssertionNotAllowed("import".into())
)
}
Callee::Expr(expr) => expr,
};
return Ok((
TsNonNullExpr {
span: span!(self, start),
expr,
}
.into(),
true,
));
}
if matches!(obj, Callee::Expr(..)) && is!(self, '<') {
let is_dynamic_import = obj.is_import();
let mut obj_opt = Some(obj);
// tsTryParseAndCatch is expensive, so avoid if not necessary.
// There are number of things we are going to "maybe" parse, like type arguments
// on tagged template expressions. If any of them fail, walk it back and
// continue.
let mut_obj_opt = &mut obj_opt;
let ctx: Context = Context {
should_not_lex_lt_or_gt_as_type: true,
..self.ctx()
};
let result = self.with_ctx(ctx).try_parse_ts(|p| {
if !no_call
&& p.at_possible_async(match &mut_obj_opt {
Some(Callee::Expr(ref expr)) => expr,
_ => unreachable!(),
})?
{
// Almost certainly this is a generic async function `async <T>() => ...
// But it might be a call with a type argument `async<T>();`
let async_arrow_fn = p.try_parse_ts_generic_async_arrow_fn(start)?;
if let Some(async_arrow_fn) = async_arrow_fn {
return Ok(Some((async_arrow_fn.into(), true)));
}
}
let type_args = p.parse_ts_type_args()?;
if !no_call && is!(p, '(') {
// possibleAsync always false here, because we would have handled it
// above. (won't be any undefined arguments)
let args = p.parse_args(is_dynamic_import)?;
let obj = mut_obj_opt.take().unwrap();
if let Callee::Expr(callee) = &obj {
if let Expr::OptChain(..) = &**callee {
return Ok(Some((
OptChainExpr {
span: span!(p, start),
base: Box::new(OptChainBase::Call(OptCall {
span: span!(p, start),
callee: obj.expect_expr(),
type_args: Some(type_args),
args,
..Default::default()
})),
optional: false,
}
.into(),
true,
)));
}
}
Ok(Some((
CallExpr {
span: span!(p, start),
callee: obj,
type_args: Some(type_args),
args,
..Default::default()
}
.into(),
true,
)))
} else if is!(p, '`') {
p.parse_tagged_tpl(
match mut_obj_opt {
Some(Callee::Expr(obj)) => obj.take(),
_ => unreachable!(),
},
Some(type_args),
)
.map(|expr| (expr.into(), true))
.map(Some)
} else if is_one_of!(p, '=', "as", "satisfies") {
Ok(Some((
TsInstantiation {
span: span!(p, start),
expr: match mut_obj_opt {
Some(Callee::Expr(obj)) => obj.take(),
_ => unreachable!(),
},
type_args,
}
.into(),
false,
)))
} else if no_call {
unexpected!(p, "`")
} else {
unexpected!(p, "( or `")
}
});
if let Some(result) = result {
return Ok(result);
}
obj = obj_opt.unwrap();
}
}
let type_args = if self.syntax().typescript() && is!(self, '<') {
self.try_parse_ts_type_args()
} else {
None
};
if obj.is_import() && !is_one_of!(self, '.', '(') {
unexpected!(self, "`.` or `(`")
}
let question_dot_token = if is!(self, '?') && peeked_is!(self, '.') {
let start = cur_pos!(self);
eat!(self, '?');
Some(span!(self, start))
} else {
None
};
// $obj[name()]
if !no_computed_member
&& ((question_dot_token.is_some()
&& is!(self, '.')
&& peeked_is!(self, '[')
&& eat!(self, '.')
&& eat!(self, '['))
|| eat!(self, '['))
{
let bracket_lo = self.input.prev_span().lo;
let prop = self.include_in_expr(true).parse_expr()?;
expect!(self, ']');
let span = Span::new(obj.span_lo(), self.input.last_pos());
debug_assert_eq!(obj.span_lo(), span.lo());
let prop = ComputedPropName {
span: Span::new(bracket_lo, self.input.last_pos()),
expr: prop,
};
let type_args = if self.syntax().typescript() && is!(self, '<') {
self.try_parse_ts_type_args()
} else {
None
};
return Ok((
Box::new(match obj {
Callee::Import(..) => unreachable!(),
Callee::Super(obj) => {
if !self.ctx().allow_direct_super
&& !self.input.syntax().allow_super_outside_method()
{
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuper);
} else if question_dot_token.is_some() {
if no_call {
syntax_error!(
self,
self.input.cur_span(),
SyntaxError::InvalidSuperCall
);
}
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuper);
} else {
SuperPropExpr {
span,
obj,
prop: SuperProp::Computed(prop),
}
.into()
}
}
Callee::Expr(obj) => {
let is_opt_chain = unwrap_ts_non_null(&obj).is_opt_chain();
let expr = MemberExpr {
span,
obj,
prop: MemberProp::Computed(prop),
};
let expr = if is_opt_chain || question_dot_token.is_some() {
OptChainExpr {
span,
optional: question_dot_token.is_some(),
base: Box::new(OptChainBase::Member(expr)),
}
.into()
} else {
expr.into()
};
if let Some(type_args) = type_args {
TsInstantiation {
expr: Box::new(expr),
type_args,
span: span!(self, start),
}
.into()
} else {
expr
}
}
}),
true,
));
}
if (question_dot_token.is_some()
&& is!(self, '.')
&& (peeked_is!(self, '(') || (self.syntax().typescript() && peeked_is!(self, '<')))
&& eat!(self, '.'))
|| (!no_call && (is!(self, '(')))
{
let type_args = if self.syntax().typescript() && is!(self, '<') {
self.parse_ts_type_args().map(Some)?
} else {
None
};
let args = self.parse_args(obj.is_import())?;
let span = span!(self, start);
return if question_dot_token.is_some()
|| match &obj {
Callee::Expr(obj) => unwrap_ts_non_null(obj).is_opt_chain(),
_ => false,
} {
match obj {
Callee::Super(_) | Callee::Import(_) => {
syntax_error!(self, self.input.cur_span(), SyntaxError::SuperCallOptional)
}
Callee::Expr(callee) => Ok((
OptChainExpr {
span,
optional: question_dot_token.is_some(),
base: Box::new(OptChainBase::Call(OptCall {
span: span!(self, start),
callee,
args,
type_args,
..Default::default()
})),
}
.into(),
true,
)),
}
} else {
Ok((
CallExpr {
span: span!(self, start),
callee: obj,
args,
..Default::default()
}
.into(),
true,
))
};
}
// member expression
// $obj.name
if eat!(self, '.') {
let prop = self.parse_maybe_private_name().map(|e| match e {
Either::Left(p) => MemberProp::PrivateName(p),
Either::Right(i) => MemberProp::Ident(i),
})?;
let span = span!(self, obj.span_lo());
debug_assert_eq!(obj.span_lo(), span.lo());
debug_assert_eq!(prop.span_hi(), span.hi());
let type_args = if self.syntax().typescript() && is!(self, '<') {
self.try_parse_ts_type_args()
} else {
None
};
return Ok((
Box::new(match obj {
callee @ Callee::Import(_) => match prop {
MemberProp::Ident(IdentName { sym, .. }) => {
if !self.ctx().can_be_module {
let span = span!(self, start);
self.emit_err(span, SyntaxError::ImportMetaInScript);
}
match &*sym {
"meta" => MetaPropExpr {
span,
kind: MetaPropKind::ImportMeta,
}
.into(),
_ => {
let args = self.parse_args(true)?;
CallExpr {
span,
callee,
args,
type_args: None,
..Default::default()
}
.into()
}
}
}
_ => {
unexpected!(self, "meta");
}
},
Callee::Super(obj) => {
if !self.ctx().allow_direct_super
&& !self.input.syntax().allow_super_outside_method()
{
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuper);
} else if question_dot_token.is_some() {
if no_call {
syntax_error!(
self,
self.input.cur_span(),
SyntaxError::InvalidSuperCall
);
}
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuper);
} else {
match prop {
MemberProp::Ident(ident) => SuperPropExpr {
span,
obj,
prop: SuperProp::Ident(ident),
}
.into(),
MemberProp::PrivateName(..) => syntax_error!(
self,
self.input.cur_span(),
SyntaxError::InvalidSuperCall
),
MemberProp::Computed(..) => unreachable!(),
}
}
}
Callee::Expr(obj) => {
let expr = MemberExpr { span, obj, prop };
let expr = if unwrap_ts_non_null(&expr.obj).is_opt_chain()
|| question_dot_token.is_some()
{
OptChainExpr {
span: span!(self, start),
optional: question_dot_token.is_some(),
base: Box::new(OptChainBase::Member(expr)),
}
.into()
} else {
expr.into()
};
if let Some(type_args) = type_args {
TsInstantiation {
expr: Box::new(expr),
type_args,
span: span!(self, start),
}
.into()
} else {
expr
}
}
}),
true,
));
}
match obj {
Callee::Expr(expr) => {
let expr = if let Some(type_args) = type_args {
TsInstantiation {
expr,
type_args,
span: span!(self, start),
}
.into()
} else {
expr
};
// MemberExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]
if is!(self, '`') {
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
let tpl = self.with_ctx(ctx).parse_tagged_tpl(expr, None)?;
return Ok((tpl.into(), true));
}
Ok((expr, false))
}
Callee::Super(..) => {
if no_call {
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuperCall);
}
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidSuper);
}
Callee::Import(..) => {
syntax_error!(self, self.input.cur_span(), SyntaxError::InvalidImport);
}
}
}
/// Parse call, dot, and `[]`-subscript expressions.
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_lhs_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_lhs_expr);
let start = cur_pos!(self);
// parse jsx
if self.input.syntax().jsx() {
fn into_expr(e: Either<JSXFragment, JSXElement>) -> Box<Expr> {
match e {
Either::Left(l) => l.into(),
Either::Right(r) => r.into(),
}
}
match *cur!(self, true) {
Token::JSXText { .. } => {
return self
.parse_jsx_text()
.map(Lit::JSXText)
.map(Expr::Lit)
.map(Box::new);
}
Token::JSXTagStart => {
return self.parse_jsx_element().map(into_expr);
}
_ => {}
}
if is!(self, '<') && !peeked_is!(self, '!') {
// In case we encounter an lt token here it will always be the start of
// jsx as the lt sign is not allowed in places that expect an expression
// FIXME:
// self.finishToken(tt.jsxTagStart);
return self.parse_jsx_element().map(into_expr);
}
}
// `super()` can't be handled from parse_new_expr()
if eat!(self, "super") {
let obj = Callee::Super(Super {
span: span!(self, start),
});
return self.parse_subscripts(obj, false, false);
}
if eat!(self, "import") {
return self.parse_dynamic_import_or_import_meta(start, false);
}
let callee = self.parse_new_expr()?;
return_if_arrow!(self, callee);
let type_args = if self.input.syntax().typescript() && is_one_of!(self, '<', "<<") {
self.try_parse_ts(|p| {
let type_args = p.parse_ts_type_args()?;
if is!(p, '(') {
Ok(Some(type_args))
} else {
Ok(None)
}
})
} else {
None
};
if let Expr::New(ne @ NewExpr { args: None, .. }) = *callee {
// If this is parsed using 'NewExpression' rule, just return it.
// Because it's not left-recursive.
if type_args.is_some() {
// This fails with `expected (`
expect!(self, '(');
}
debug_assert_ne!(
cur!(self, false).ok(),
Some(&tok!('(')),
"parse_new_expr() should eat paren if it exists"
);
return Ok(NewExpr { type_args, ..ne }.into());
}
// 'CallExpr' rule contains 'MemberExpr (...)',
// and 'MemberExpr' rule contains 'new MemberExpr (...)'
if is!(self, '(') {
// This is parsed using production MemberExpression,
// which is left-recursive.
let (callee, is_import) = match callee {
_ if callee.is_ident_ref_to("import") => (
Callee::Import(Import {
span: callee.span(),
phase: Default::default(),
}),
true,
),
_ => (Callee::Expr(callee), false),
};
let args = self.parse_args(is_import)?;
let call_expr = match callee {
Callee::Expr(e) if unwrap_ts_non_null(&e).is_opt_chain() => OptChainExpr {
span: span!(self, start),
base: Box::new(OptChainBase::Call(OptCall {
span: span!(self, start),
callee: e,
args,
type_args,
..Default::default()
})),
optional: false,
}
.into(),
_ => CallExpr {
span: span!(self, start),
callee,
args,
type_args,
..Default::default()
}
.into(),
};
return self.parse_subscripts(Callee::Expr(call_expr), false, false);
}
if type_args.is_some() {
// This fails
expect!(self, '(');
}
// This is parsed using production 'NewExpression', which contains
// 'MemberExpression'
Ok(callee)
}
pub(super) fn parse_for_head_prefix(&mut self) -> PResult<Box<Expr>> {
self.parse_expr()
}
// Returns (args_or_pats, trailing_comma)
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_args_or_pats(
&mut self,
) -> PResult<(Vec<AssignTargetOrSpread>, Option<Span>)> {
self.with_ctx(Context {
will_expect_colon_for_cond: false,
..self.ctx()
})
.parse_args_or_pats_inner()
}
fn parse_args_or_pats_inner(&mut self) -> PResult<(Vec<AssignTargetOrSpread>, Option<Span>)> {
trace_cur!(self, parse_args_or_pats);
expect!(self, '(');
let mut items = Vec::new();
let mut trailing_comma = None;
// TODO(kdy1): optimize (once we parsed a pattern, we can parse everything else
// as a pattern instead of reparsing)
while !eof!(self) && !is!(self, ')') {
// https://github.com/swc-project/swc/issues/410
let is_async = is!(self, "async")
&& matches!(
peek!(self),
Some(tok!('(') | tok!("function") | Token::Word(..))
);
let start = cur_pos!(self);
self.state.potential_arrow_start = Some(start);
let modifier_start = start;
let has_modifier = self.eat_any_ts_modifier()?;
let pat_start = cur_pos!(self);
let mut arg = {
if self.input.syntax().typescript()
&& (is!(self, IdentRef) || (is!(self, "...") && peeked_is!(self, IdentRef)))
{
let spread = if eat!(self, "...") {
Some(self.input.prev_span())
} else {
None
};
// At here, we use parse_bin_expr() instead of parse_assignment_expr()
// because `x?: number` should not be parsed as a conditional expression
let expr = if spread.is_some() {
self.include_in_expr(true).parse_bin_expr()?
} else {
let mut expr = self.parse_bin_expr()?;
if let Ok(&Token::AssignOp(..)) = cur!(self, false) {
expr = self.finish_assignment_expr(start, expr)?
}
expr
};
ExprOrSpread { spread, expr }
} else {
self.include_in_expr(true).parse_expr_or_spread()?
}
};
let optional = if self.input.syntax().typescript() {
if is!(self, '?') {
if peeked_is!(self, ',')
|| peeked_is!(self, ':')
|| peeked_is!(self, ')')
|| peeked_is!(self, '=')
{
assert_and_bump!(self, '?');
let _ = cur!(self, false);
if arg.spread.is_some() {
self.emit_err(self.input.prev_span(), SyntaxError::TS1047);
}
match *arg.expr {
Expr::Ident(..) => {}
_ => {
syntax_error!(
self,
arg.span(),
SyntaxError::TsBindingPatCannotBeOptional
)
}
}
true
} else if matches!(arg, ExprOrSpread { spread: None, .. }) {
expect!(self, '?');
let test = arg.expr;
let ctx = Context {
in_cond_expr: true,
will_expect_colon_for_cond: true,
include_in_expr: true,
..self.ctx()
};
let cons = self.with_ctx(ctx).parse_assignment_expr()?;
expect!(self, ':');
let ctx = Context {
in_cond_expr: true,
will_expect_colon_for_cond: false,
..self.ctx()
};
let alt = self.with_ctx(ctx).parse_assignment_expr()?;
arg = ExprOrSpread {
spread: None,
expr: CondExpr {
span: Span::new(start, alt.span_hi()),
test,
cons,
alt,
}
.into(),
};
false
} else {
false
}
} else {
false
}
} else {
false
};
if optional || (self.input.syntax().typescript() && is!(self, ':')) {
// TODO: `async(...args?: any[]) : any => {}`
//
// if self.input.syntax().typescript() && optional && arg.spread.is_some() {
// self.emit_err(self.input.prev_span(), SyntaxError::TS1047)
// }
let mut pat = self.reparse_expr_as_pat(PatType::BindingPat, arg.expr)?;
if optional {
match pat {
Pat::Ident(ref mut i) => i.optional = true,
_ => unreachable!(),
}
}
if let Some(span) = arg.spread {
pat = RestPat {
span: span!(self, pat_start),
dot3_token: span,
arg: Box::new(pat),
type_ann: None,
}
.into();
}
match pat {
Pat::Ident(BindingIdent {
id: Ident { ref mut span, .. },
ref mut type_ann,
..
})
| Pat::Array(ArrayPat {
ref mut type_ann,
ref mut span,
..
})
| Pat::Object(ObjectPat {
ref mut type_ann,
ref mut span,
..
})
| Pat::Rest(RestPat {
ref mut type_ann,
ref mut span,
..
}) => {
let new_type_ann = self.try_parse_ts_type_ann()?;
if new_type_ann.is_some() {
*span = Span::new(pat_start, self.input.prev_span().hi);
}
*type_ann = new_type_ann;
}
Pat::Expr(ref expr) => unreachable!("invalid pattern: Expr({:?})", expr),
Pat::Assign(..) | Pat::Invalid(..) => {
// We don't have to panic here.
// See: https://github.com/swc-project/swc/issues/1170
//
// Also, as an exact error is added to the errors while
// creating `Invalid`, we don't have to emit a new
// error.
}
}
if eat!(self, '=') {
let right = self.parse_assignment_expr()?;
pat = AssignPat {
span: span!(self, pat_start),
left: Box::new(pat),
right,
}
.into();
}
if has_modifier {
self.emit_err(span!(self, modifier_start), SyntaxError::TS2369);
}
items.push(AssignTargetOrSpread::Pat(pat))
} else {
if has_modifier {
self.emit_err(span!(self, modifier_start), SyntaxError::TS2369);
}
items.push(AssignTargetOrSpread::ExprOrSpread(arg));
}
// https://github.com/swc-project/swc/issues/433
if eat!(self, "=>") && {
debug_assert_eq!(items.len(), 1);
match items[0] {
AssignTargetOrSpread::ExprOrSpread(ExprOrSpread { ref expr, .. })
| AssignTargetOrSpread::Pat(Pat::Expr(ref expr)) => {
matches!(**expr, Expr::Ident(..))
}
AssignTargetOrSpread::Pat(Pat::Ident(..)) => true,
_ => false,
}
} {
let params: Vec<Pat> = self
.parse_paren_items_as_params(items.clone(), None)?
.into_iter()
.collect();
let body: Box<BlockStmtOrExpr> =
self.parse_fn_body(false, false, true, params.is_simple_parameter_list())?;
let span = span!(self, start);
items.push(AssignTargetOrSpread::ExprOrSpread(ExprOrSpread {
expr: Box::new(
ArrowExpr {
span,
body,
is_async,
is_generator: false,
params,
..Default::default()
}
.into(),
),
spread: None,
}));
}
if !is!(self, ')') {
expect!(self, ',');
if is!(self, ')') {
trailing_comma = Some(self.input.prev_span());
}
}
}
expect!(self, ')');
Ok((items, trailing_comma))
}
}
#[ast_node]
pub(in crate::parser) enum AssignTargetOrSpread {
#[tag("ExprOrSpread")]
ExprOrSpread(ExprOrSpread),
#[tag("*")]
Pat(Pat),
}
/// simple leaf methods.
impl<I: Tokens> Parser<I> {
fn parse_yield_expr(&mut self) -> PResult<Box<Expr>> {
let start = cur_pos!(self);
assert_and_bump!(self, "yield");
debug_assert!(self.ctx().in_generator);
// Spec says
// YieldExpression cannot be used within the FormalParameters of a generator
// function because any expressions that are part of FormalParameters are
// evaluated before the resulting generator object is in a resumable state.
if self.ctx().in_parameters && !self.ctx().in_function {
syntax_error!(self, self.input.prev_span(), SyntaxError::YieldParamInGen)
}
if is!(self, ';')
|| (!is!(self, '<')
&& !is!(self, '*')
&& !is!(self, '/')
&& !is!(self, "/=")
&& !cur!(self, false)
.map(|t| t.kind().starts_expr())
.unwrap_or(true))
{
Ok(YieldExpr {
span: span!(self, start),
arg: None,
delegate: false,
}
.into())
} else {
let has_star = eat!(self, '*');
let err_span = span!(self, start);
let arg = self.parse_assignment_expr().map_err(|err| {
Error::new(
err.span(),
SyntaxError::WithLabel {
inner: Box::new(err),
span: err_span,
note: "Tried to parse an argument of yield",
},
)
})?;
Ok(YieldExpr {
span: span!(self, start),
arg: Some(arg),
delegate: has_star,
}
.into())
}
}
fn at_possible_async(&mut self, expr: &Expr) -> PResult<bool> {
// TODO(kdy1): !this.state.containsEsc &&
Ok(self.state.potential_arrow_start == Some(expr.span_lo())
&& expr.is_ident_ref_to("async"))
}
/// 12.2.5 Array Initializer
pub(super) fn parse_lit(&mut self) -> PResult<Lit> {
let start = cur_pos!(self);
let v = match cur!(self, true) {
Word(Word::Null) => {
bump!(self);
let span = span!(self, start);
Lit::Null(Null { span })
}
Word(Word::True) | Word(Word::False) => {
let value = is!(self, "true");
bump!(self);
let span = span!(self, start);
Lit::Bool(Bool { span, value })
}
Token::Str { .. } => match bump!(self) {
Token::Str { value, raw } => Lit::Str(Str {
span: span!(self, start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
Token::Num { .. } => match bump!(self) {
Token::Num { value, raw } => Lit::Num(Number {
span: span!(self, start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
Token::BigInt { .. } => match bump!(self) {
Token::BigInt { value, raw } => Lit::BigInt(BigInt {
span: span!(self, start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
token => unreachable!("parse_lit should not be called for {:?}", token),
};
Ok(v)
}
pub(super) fn parse_dynamic_import_or_import_meta(
&mut self,
start: BytePos,
no_call: bool,
) -> PResult<Box<Expr>> {
if eat!(self, '.') {
self.state.found_module_item = true;
let ident = self.parse_ident_name()?;
match &*ident.sym {
"meta" => {
let span = span!(self, start);
if !self.ctx().can_be_module {
self.emit_err(span, SyntaxError::ImportMetaInScript);
}
let expr = MetaPropExpr {
span,
kind: MetaPropKind::ImportMeta,
};
self.parse_subscripts(Callee::Expr(expr.into()), no_call, false)
}
"source" => self.parse_dynamic_import_call(start, no_call, ImportPhase::Source),
// TODO: The proposal doesn't mention import.defer yet because it was
// pending on a decision for import.source. Wait to enable it until it's
// included in the proposal.
_ => unexpected!(self, "meta"),
}
} else {
self.parse_dynamic_import_call(start, no_call, ImportPhase::Evaluation)
}
}
fn parse_dynamic_import_call(
&mut self,
start: BytePos,
no_call: bool,
phase: ImportPhase,
) -> PResult<Box<Expr>> {
let import = Callee::Import(Import {
span: span!(self, start),
phase,
});
self.parse_subscripts(import, no_call, false)
}
pub(super) fn check_assign_target(&mut self, expr: &Expr, deny_call: bool) {
if !expr.is_valid_simple_assignment_target(self.ctx().strict) {
self.emit_err(expr.span(), SyntaxError::TS2406);
}
// We follow behavior of tsc
if self.input.syntax().typescript() && self.syntax().early_errors() {
let is_eval_or_arguments = match expr {
Expr::Ident(i) => i.is_reserved_in_strict_bind(),
_ => false,
};
if is_eval_or_arguments {
self.emit_strict_mode_err(expr.span(), SyntaxError::TS1100);
}
fn should_deny(e: &Expr, deny_call: bool) -> bool {
match e {
Expr::Lit(..) => false,
Expr::Call(..) => deny_call,
Expr::Bin(..) => false,
Expr::Paren(ref p) => should_deny(&p.expr, deny_call),
_ => true,
}
}
// It is an early Reference Error if LeftHandSideExpression is neither
// an ObjectLiteral nor an ArrayLiteral and
// IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.
if !is_eval_or_arguments
&& !expr.is_valid_simple_assignment_target(self.ctx().strict)
&& should_deny(expr, deny_call)
{
self.emit_err(expr.span(), SyntaxError::TS2406);
}
}
}
fn is_start_of_left_hand_side_expr(&mut self) -> PResult<bool> {
Ok(is_one_of!(
self, "this", "super", "null", "true", "false", Num, BigInt, Str, '`', '(', '[', '{',
"function", "class", "new", Regex, IdentRef
) || (is!(self, "import")
&& (peeked_is!(self, '(') || peeked_is!(self, '<') || peeked_is!(self, '.'))))
}
pub(super) fn is_start_of_expr(&mut self) -> PResult<bool> {
Ok(self.is_start_of_left_hand_side_expr()?
|| is_one_of!(
self, '+', '-', '~', '!', "delete", "typeof", "void", "++", "--", '<', "await",
"yield"
)
|| (is!(self, '#') && peeked_is!(self, IdentName)))
}
}
fn unwrap_ts_non_null(mut expr: &Expr) -> &Expr {
while let Expr::TsNonNull(ts_non_null) = expr {
expr = &ts_non_null.expr;
}
expr
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/expr/ops.rs | Rust | //! Parser for unary operations and binary operations.
use tracing::trace;
use super::*;
impl<I: Tokens> Parser<I> {
/// Name from spec: 'LogicalORExpression'
pub(super) fn parse_bin_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_bin_expr);
let ctx = self.ctx();
let left = match self.parse_unary_expr() {
Ok(v) => v,
Err(err) => {
trace_cur!(self, parse_bin_expr__recovery_unary_err);
match cur!(self, true) {
&tok!("in") if ctx.include_in_expr => {
self.emit_err(self.input.cur_span(), SyntaxError::TS1109);
Invalid { span: err.span() }.into()
}
&tok!("instanceof") | &Token::BinOp(..) => {
self.emit_err(self.input.cur_span(), SyntaxError::TS1109);
Invalid { span: err.span() }.into()
}
_ => return Err(err),
}
}
};
return_if_arrow!(self, left);
self.parse_bin_op_recursively(left, 0)
}
/// Parse binary operators with the operator precedence parsing
/// algorithm. `left` is the left-hand side of the operator.
/// `minPrec` provides context that allows the function to stop and
/// defer further parser to one of its callers when it encounters an
/// operator that has a lower precedence than the set it is parsing.
///
/// `parseExprOp`
pub(in crate::parser) fn parse_bin_op_recursively(
&mut self,
mut left: Box<Expr>,
mut min_prec: u8,
) -> PResult<Box<Expr>> {
loop {
let (next_left, next_prec) = self.parse_bin_op_recursively_inner(left, min_prec)?;
match &*next_left {
Expr::Bin(BinExpr {
span,
left,
op: op!("&&"),
..
})
| Expr::Bin(BinExpr {
span,
left,
op: op!("||"),
..
}) => {
if let Expr::Bin(BinExpr { op: op!("??"), .. }) = &**left {
self.emit_err(*span, SyntaxError::NullishCoalescingWithLogicalOp);
}
}
_ => {}
}
min_prec = match next_prec {
Some(v) => v,
None => return Ok(next_left),
};
left = next_left;
}
}
/// Returns `(left, Some(next_prec))` or `(expr, None)`.
fn parse_bin_op_recursively_inner(
&mut self,
left: Box<Expr>,
min_prec: u8,
) -> PResult<(Box<Expr>, Option<u8>)> {
const PREC_OF_IN: u8 = 7;
if self.input.syntax().typescript()
&& PREC_OF_IN > min_prec
&& !self.input.had_line_break_before_cur()
&& is!(self, "as")
{
let start = left.span_lo();
let expr = left;
let node = if peeked_is!(self, "const") {
bump!(self); // as
let _ = cur!(self, false);
bump!(self); // const
TsConstAssertion {
span: span!(self, start),
expr,
}
.into()
} else {
let type_ann = self.next_then_parse_ts_type()?;
TsAsExpr {
span: span!(self, start),
expr,
type_ann,
}
.into()
};
return self.parse_bin_op_recursively_inner(node, min_prec);
}
if self.input.syntax().typescript()
&& !self.input.had_line_break_before_cur()
&& is!(self, "satisfies")
{
let start = left.span_lo();
let expr = left;
let node = {
let type_ann = self.next_then_parse_ts_type()?;
TsSatisfiesExpr {
span: span!(self, start),
expr,
type_ann,
}
.into()
};
return self.parse_bin_op_recursively_inner(node, min_prec);
}
let ctx = self.ctx();
// Return left on eof
let word = match cur!(self, false) {
Ok(cur) => cur,
Err(..) => return Ok((left, None)),
};
let op = match *word {
tok!("in") if ctx.include_in_expr => op!("in"),
tok!("instanceof") => op!("instanceof"),
Token::BinOp(op) => op.into(),
_ => {
return Ok((left, None));
}
};
if op.precedence() <= min_prec {
if cfg!(feature = "debug") {
trace!(
"returning {:?} without parsing {:?} because min_prec={}, prec={}",
left,
op,
min_prec,
op.precedence()
);
}
return Ok((left, None));
}
bump!(self);
if cfg!(feature = "debug") {
trace!(
"parsing binary op {:?} min_prec={}, prec={}",
op,
min_prec,
op.precedence()
);
}
match *left {
// This is invalid syntax.
Expr::Unary { .. } | Expr::Await(..) if op == op!("**") => {
// Correct implementation would be returning Ok(left) and
// returning "unexpected token '**'" on next.
// But it's not useful error message.
syntax_error!(
self,
SyntaxError::UnaryInExp {
// FIXME: Use display
left: format!("{:?}", left),
left_span: left.span(),
}
)
}
_ => {}
}
let right = {
let left_of_right = self.parse_unary_expr()?;
self.parse_bin_op_recursively(
left_of_right,
if op == op!("**") {
// exponential operator is right associative
op.precedence() - 1
} else {
op.precedence()
},
)?
};
/* this check is for all ?? operators
* a ?? b && c for this example
* b && c => This is considered as a logical expression in the ast tree
* a => Identifier
* so for ?? operator we need to check in this case the right expression to
* have parenthesis second case a && b ?? c
* here a && b => This is considered as a logical expression in the ast tree
* c => identifier
* so now here for ?? operator we need to check the left expression to have
* parenthesis if the parenthesis is missing we raise an error and
* throw it
*/
if op == op!("??") {
match *left {
Expr::Bin(BinExpr { span, op, .. }) if op == op!("&&") || op == op!("||") => {
self.emit_err(span, SyntaxError::NullishCoalescingWithLogicalOp);
}
_ => {}
}
match *right {
Expr::Bin(BinExpr { span, op, .. }) if op == op!("&&") || op == op!("||") => {
self.emit_err(span, SyntaxError::NullishCoalescingWithLogicalOp);
}
_ => {}
}
}
let node = BinExpr {
span: Span::new(left.span_lo(), right.span_hi()),
op,
left,
right,
}
.into();
Ok((node, Some(min_prec)))
}
/// Parse unary expression and update expression.
///
/// spec: 'UnaryExpression'
pub(in crate::parser) fn parse_unary_expr(&mut self) -> PResult<Box<Expr>> {
trace_cur!(self, parse_unary_expr);
let start = cur_pos!(self);
if !self.input.syntax().jsx() && self.input.syntax().typescript() && eat!(self, '<') {
if eat!(self, "const") {
expect!(self, '>');
let expr = self.parse_unary_expr()?;
return Ok(TsConstAssertion {
span: span!(self, start),
expr,
}
.into());
}
return self
.parse_ts_type_assertion(start)
.map(Expr::from)
.map(Box::new);
}
// Parse update expression
if is!(self, "++") || is!(self, "--") {
let op = if bump!(self) == tok!("++") {
op!("++")
} else {
op!("--")
};
let arg = self.parse_unary_expr()?;
let span = Span::new(start, arg.span_hi());
self.check_assign_target(&arg, false);
return Ok(UpdateExpr {
span,
prefix: true,
op,
arg,
}
.into());
}
// Parse unary expression
if is_one_of!(self, "delete", "void", "typeof", '+', '-', '~', '!') {
let op = match bump!(self) {
tok!("delete") => op!("delete"),
tok!("void") => op!("void"),
tok!("typeof") => op!("typeof"),
tok!('+') => op!(unary, "+"),
tok!('-') => op!(unary, "-"),
tok!('~') => op!("~"),
tok!('!') => op!("!"),
_ => unreachable!(),
};
let arg_start = cur_pos!(self) - BytePos(1);
let arg = match self.parse_unary_expr() {
Ok(expr) => expr,
Err(err) => {
self.emit_error(err);
Invalid {
span: Span::new(arg_start, arg_start),
}
.into()
}
};
if op == op!("delete") {
if let Expr::Ident(ref i) = *arg {
self.emit_strict_mode_err(i.span, SyntaxError::TS1102)
}
}
if self.input.syntax().typescript() && op == op!("delete") {
match arg.unwrap_parens() {
Expr::Member(..) => {}
Expr::OptChain(OptChainExpr { base, .. })
if matches!(&**base, OptChainBase::Member(..)) => {}
expr => {
self.emit_err(expr.span(), SyntaxError::TS2703);
}
}
}
return Ok(UnaryExpr {
span: Span::new(start, arg.span_hi()),
op,
arg,
}
.into());
}
if is!(self, "await") {
return self.parse_await_expr(None);
}
// UpdateExpression
let expr = self.parse_lhs_expr()?;
return_if_arrow!(self, expr);
// Line terminator isn't allowed here.
if self.input.had_line_break_before_cur() {
return Ok(expr);
}
if is_one_of!(self, "++", "--") {
self.check_assign_target(&expr, false);
let op = if bump!(self) == tok!("++") {
op!("++")
} else {
op!("--")
};
return Ok(UpdateExpr {
span: span!(self, expr.span_lo()),
prefix: false,
op,
arg: expr,
}
.into());
}
Ok(expr)
}
pub(crate) fn parse_await_expr(
&mut self,
start_of_await_token: Option<BytePos>,
) -> PResult<Box<Expr>> {
let start = start_of_await_token.unwrap_or_else(|| cur_pos!(self));
if start_of_await_token.is_none() {
assert_and_bump!(self, "await");
}
if is!(self, '*') {
syntax_error!(self, SyntaxError::AwaitStar);
}
let ctx = self.ctx();
let span = span!(self, start);
if is_one_of!(self, ')', ']', ';', ',') && !ctx.in_async {
if ctx.module {
self.emit_err(span, SyntaxError::InvalidIdentInAsync);
}
return Ok(Ident::new_no_ctxt("await".into(), span).into());
}
if ctx.in_function && !ctx.in_async {
self.emit_err(self.input.cur_span(), SyntaxError::AwaitInFunction);
}
if ctx.in_parameters && !ctx.in_function {
self.emit_err(span, SyntaxError::AwaitParamInAsync);
}
let arg = self.parse_unary_expr()?;
Ok(AwaitExpr {
span: span!(self, start),
arg,
}
.into())
}
}
#[cfg(test)]
mod tests {
use swc_common::DUMMY_SP as span;
use swc_ecma_visit::assert_eq_ignore_span;
use super::*;
fn bin(s: &'static str) -> Box<Expr> {
test_parser(s, Syntax::default(), |p| p.parse_bin_expr())
}
#[test]
fn simple() {
assert_eq_ignore_span!(
bin("5 + 4 * 7"),
Box::new(Expr::Bin(BinExpr {
span,
op: op!(bin, "+"),
left: bin("5"),
right: bin("4 * 7"),
}))
);
}
#[test]
fn same_prec() {
assert_eq_ignore_span!(
bin("5 + 4 + 7"),
Box::new(Expr::Bin(BinExpr {
span,
op: op!(bin, "+"),
left: bin("5 + 4"),
right: bin("7"),
}))
);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/expr/tests.rs | Rust | use std::hint::black_box;
use swc_common::{FileName, SourceMap, DUMMY_SP as span};
use swc_ecma_visit::assert_eq_ignore_span;
use super::*;
use crate::{parse_file_as_expr, EsSyntax};
fn syntax() -> Syntax {
Syntax::Es(EsSyntax {
allow_super_outside_method: true,
..Default::default()
})
}
fn lhs(s: &'static str) -> Box<Expr> {
test_parser(s, syntax(), |p| p.parse_lhs_expr())
}
fn new_expr(s: &'static str) -> Box<Expr> {
test_parser(s, syntax(), |p| p.parse_new_expr())
}
fn member_expr(s: &'static str) -> Box<Expr> {
test_parser(s, syntax(), |p| p.parse_member_expr())
}
fn expr(s: &'static str) -> Box<Expr> {
test_parser(s, syntax(), |p| {
p.parse_stmt(true).map(|stmt| match stmt {
Stmt::Expr(expr) => expr.expr,
_ => unreachable!(),
})
})
}
fn regex_expr() -> Box<Expr> {
AssignExpr {
span,
left: Ident::new_no_ctxt("re".into(), span).into(),
op: AssignOp::Assign,
right: Box::new(
Lit::Regex(Regex {
span,
exp: "w+".into(),
flags: "".into(),
})
.into(),
),
}
.into()
}
#[test]
fn regex_single_line_comment() {
assert_eq_ignore_span!(
expr(
r#"re = // ...
/w+/"#
),
regex_expr()
)
}
#[test]
fn regex_multi_line_comment() {
assert_eq_ignore_span!(expr(r#"re = /* ... *//w+/"#), regex_expr())
}
#[test]
fn regex_multi_line_comment_with_lines() {
assert_eq_ignore_span!(
expr(
r#"re =
/*
...
*/
/w+/"#
),
regex_expr()
)
}
#[test]
fn arrow_assign() {
assert_eq_ignore_span!(
expr("a = b => false"),
Box::new(Expr::Assign(AssignExpr {
span,
left: Ident::new_no_ctxt("a".into(), span).into(),
op: op!("="),
right: expr("b => false"),
}))
);
}
#[test]
fn async_call() {
assert_eq_ignore_span!(
expr("async()"),
Box::new(Expr::Call(CallExpr {
span,
callee: Callee::Expr(expr("async")),
args: Vec::new(),
..Default::default()
}))
);
}
#[test]
fn async_arrow() {
assert_eq_ignore_span!(
expr("async () => foo"),
Box::new(Expr::Arrow(ArrowExpr {
span,
is_async: true,
is_generator: false,
params: Vec::new(),
body: Box::new(BlockStmtOrExpr::Expr(expr("foo"))),
..Default::default()
}))
);
}
#[test]
fn object_rest_pat() {
assert_eq_ignore_span!(
expr("({ ...a34 }) => {}"),
Box::new(Expr::Arrow(ArrowExpr {
span,
is_async: false,
is_generator: false,
params: vec![Pat::Object(ObjectPat {
span,
optional: false,
props: vec![ObjectPatProp::Rest(RestPat {
span,
dot3_token: span,
arg: Box::new(Pat::Ident(Ident::new_no_ctxt("a34".into(), span).into())),
type_ann: None,
})],
type_ann: None
})],
body: Box::new(BlockStmtOrExpr::BlockStmt(BlockStmt {
span,
..Default::default()
})),
..Default::default()
}))
);
}
#[test]
fn object_spread() {
assert_eq_ignore_span!(
expr("foo = {a, ...bar, b}"),
Box::new(Expr::Assign(AssignExpr {
span,
left: Ident::new_no_ctxt("foo".into(), span).into(),
op: op!("="),
right: Box::new(Expr::Object(ObjectLit {
span,
props: vec![
PropOrSpread::Prop(Box::new(Ident::new_no_ctxt("a".into(), span).into())),
PropOrSpread::Spread(SpreadElement {
dot3_token: span,
expr: Box::new(Expr::Ident(Ident::new_no_ctxt("bar".into(), span))),
}),
PropOrSpread::Prop(Box::new(Ident::new_no_ctxt("b".into(), span).into())),
]
}))
}))
);
}
#[test]
fn new_expr_should_not_eat_too_much() {
assert_eq_ignore_span!(
new_expr("new Date().toString()"),
Box::new(Expr::Member(MemberExpr {
span,
obj: member_expr("new Date()"),
prop: MemberProp::Ident(IdentName::new("toString".into(), span)),
}))
);
}
#[test]
fn lhs_expr_as_new_expr_prod() {
assert_eq_ignore_span!(
lhs("new Date.toString()"),
Box::new(Expr::New(NewExpr {
span,
callee: lhs("Date.toString"),
args: Some(Vec::new()),
..Default::default()
}))
);
}
#[test]
fn lhs_expr_as_call() {
assert_eq_ignore_span!(
lhs("new Date.toString()()"),
Box::new(Expr::Call(CallExpr {
span,
callee: Callee::Expr(lhs("new Date.toString()")),
args: Vec::new(),
..Default::default()
}))
)
}
#[test]
fn arrow_fn_no_args() {
assert_eq_ignore_span!(
expr("() => 1"),
Box::new(Expr::Arrow(ArrowExpr {
span,
is_async: false,
is_generator: false,
params: Vec::new(),
body: Box::new(BlockStmtOrExpr::Expr(expr("1"))),
..Default::default()
}))
);
}
#[test]
fn arrow_fn() {
assert_eq_ignore_span!(
expr("(a) => 1"),
Box::new(Expr::Arrow(ArrowExpr {
span,
is_async: false,
is_generator: false,
params: vec![Pat::Ident(Ident::new_no_ctxt("a".into(), span).into())],
body: Box::new(BlockStmtOrExpr::Expr(expr("1"))),
..Default::default()
}))
);
}
#[test]
fn arrow_fn_rest() {
assert_eq_ignore_span!(
expr("(...a) => 1"),
Box::new(Expr::Arrow(ArrowExpr {
span,
is_async: false,
is_generator: false,
params: vec![Pat::Rest(RestPat {
span,
dot3_token: span,
arg: Box::new(Pat::Ident(Ident::new_no_ctxt("a".into(), span).into())),
type_ann: None
})],
body: Box::new(BlockStmtOrExpr::Expr(expr("1"))),
..Default::default()
}))
);
}
#[test]
fn arrow_fn_no_paren() {
assert_eq_ignore_span!(
expr("a => 1"),
Box::new(Expr::Arrow(ArrowExpr {
span,
params: vec![Pat::Ident(Ident::new_no_ctxt("a".into(), span).into())],
body: Box::new(BlockStmtOrExpr::Expr(expr("1"))),
..Default::default()
}))
);
}
#[test]
fn new_no_paren() {
assert_eq_ignore_span!(
expr("new a"),
Box::new(Expr::New(NewExpr {
span,
callee: expr("a"),
args: None,
..Default::default()
}))
);
}
#[test]
fn new_new_no_paren() {
assert_eq_ignore_span!(
expr("new new a"),
Box::new(Expr::New(NewExpr {
span,
callee: expr("new a"),
args: None,
..Default::default()
}))
);
}
#[test]
fn array_lit() {
assert_eq_ignore_span!(
expr("[a,,,,, ...d,, e]"),
Box::new(Expr::Array(ArrayLit {
span,
elems: vec![
Some(ExprOrSpread {
spread: None,
expr: Box::new(Expr::Ident(Ident::new_no_ctxt("a".into(), span))),
}),
None,
None,
None,
None,
Some(ExprOrSpread {
spread: Some(span),
expr: Box::new(Expr::Ident(Ident::new_no_ctxt("d".into(), span))),
}),
None,
Some(ExprOrSpread {
spread: None,
expr: Box::new(Expr::Ident(Ident::new_no_ctxt("e".into(), span))),
}),
]
}))
);
}
#[test]
fn max_integer() {
assert_eq_ignore_span!(
expr("1.7976931348623157e+308"),
Box::new(Expr::Lit(Lit::Num(Number {
span,
value: 1.797_693_134_862_315_7e308,
raw: Some("1.7976931348623157e+308".into()),
})))
)
}
#[test]
fn iife() {
assert_eq_ignore_span!(
expr("(function(){})()"),
Box::new(Expr::Call(CallExpr {
span,
callee: Callee::Expr(expr("(function(){})")),
args: Vec::new(),
..Default::default()
}))
)
}
#[test]
fn issue_319_1() {
assert_eq_ignore_span!(
expr("obj(({ async f() { await g(); } }));"),
Box::new(Expr::Call(CallExpr {
span,
callee: Callee::Expr(expr("obj")),
args: vec![ExprOrSpread {
spread: None,
expr: expr("({ async f() { await g(); } })"),
}],
..Default::default()
}))
);
}
#[test]
fn issue_328() {
assert_eq_ignore_span!(
test_parser("import('test')", Syntax::Es(Default::default()), |p| {
p.parse_stmt(true)
}),
Stmt::Expr(ExprStmt {
span,
expr: Box::new(Expr::Call(CallExpr {
span,
callee: Callee::Import(Import {
span,
phase: Default::default()
}),
args: vec![ExprOrSpread {
spread: None,
expr: Box::new(Expr::Lit(Lit::Str(Str {
span,
value: "test".into(),
raw: Some("'test'".into()),
}))),
}],
..Default::default()
}))
})
);
}
#[test]
fn issue_337() {
test_parser(
"const foo = 'bar' in bas ? 'beep' : 'boop';",
Default::default(),
|p| p.parse_module(),
);
}
#[test]
fn issue_350() {
assert_eq_ignore_span!(
expr(
r#""ok\
ok\
hehe.";"#,
),
Box::new(Expr::Lit(Lit::Str(Str {
span,
value: "okokhehe.".into(),
raw: Some("\"ok\\\nok\\\nhehe.\"".into()),
})))
);
}
#[test]
fn issue_380() {
expr(
" import('../foo/bar')
.then(bar => {
// bar should be {default: DEFAULT_EXPORTED_THING_IN_BAR} or at least what it is supposed \
to be
})
}",
);
}
#[test]
fn issue_675() {
expr("fn = function () { Object.setPrototypeOf(this, new.target.prototype); }");
}
#[test]
fn super_expr() {
assert_eq_ignore_span!(
expr("super.foo();"),
Box::new(Expr::Call(CallExpr {
span,
callee: Callee::Expr(Box::new(Expr::SuperProp(SuperPropExpr {
span,
obj: Super { span },
prop: SuperProp::Ident(IdentName {
span,
sym: "foo".into(),
})
}))),
..Default::default()
}))
);
}
#[test]
fn super_expr_computed() {
assert_eq_ignore_span!(
expr("super[a] ??= 123;"),
Box::new(Expr::Assign(AssignExpr {
span,
op: AssignOp::NullishAssign,
left: SuperPropExpr {
span,
obj: Super { span },
prop: SuperProp::Computed(ComputedPropName {
span,
expr: Box::new(Expr::Ident(Ident {
span,
sym: "a".into(),
..Default::default()
})),
})
}
.into(),
right: Box::new(Expr::Lit(Lit::Num(Number {
span,
value: 123f64,
raw: Some("123".into()),
})))
}))
);
}
#[test]
fn issue_3672_1() {
test_parser(
"report({
fix: fixable ? null : (): RuleFix => {},
});",
Syntax::Typescript(Default::default()),
|p| p.parse_module(),
);
}
#[test]
fn issue_3672_2() {
test_parser(
"f(a ? (): void => { } : (): void => { })",
Syntax::Typescript(Default::default()),
|p| p.parse_module(),
);
}
#[test]
fn issue_5947() {
test_parser(
"[a as number, b as number, c as string] = [1, 2, '3']",
Syntax::Typescript(Default::default()),
|p| p.parse_module(),
);
}
#[test]
fn issue_6781() {
let cm = SourceMap::default();
let fm = cm.new_source_file(FileName::Anon.into(), "import.meta.env".to_string());
let mut errors = Vec::new();
let expr = parse_file_as_expr(
&fm,
Default::default(),
Default::default(),
None,
&mut errors,
);
assert!(expr.is_ok());
assert!(errors.is_empty());
}
#[bench]
fn bench_new_expr_ts(b: &mut Bencher) {
bench_parser(
b,
"new Foo()",
Syntax::Typescript(Default::default()),
|p| {
black_box(p.parse_expr()?);
Ok(())
},
);
}
#[bench]
fn bench_new_expr_es(b: &mut Bencher) {
bench_parser(b, "new Foo()", Syntax::Es(Default::default()), |p| {
black_box(p.parse_expr()?);
Ok(())
});
}
#[bench]
fn bench_member_expr_ts(b: &mut Bencher) {
bench_parser(
b,
"a.b.c.d.e.f",
Syntax::Typescript(Default::default()),
|p| {
black_box(p.parse_expr()?);
Ok(())
},
);
}
#[bench]
fn bench_member_expr_es(b: &mut Bencher) {
bench_parser(b, "a.b.c.d.e.f", Syntax::Es(Default::default()), |p| {
black_box(p.parse_expr()?);
Ok(())
});
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/expr/verifier.rs | Rust | #[cfg(feature = "verify")]
use swc_ecma_visit::{noop_visit_type, Visit, VisitWith};
use super::*;
impl<I: Tokens> Parser<I> {
#[cfg(feature = "verify")]
pub(in crate::parser) fn verify_expr(&mut self, expr: Box<Expr>) -> PResult<Box<Expr>> {
let mut v = Verifier { errors: Vec::new() };
v.visit_expr(&expr);
for (span, error) in v.errors {
self.emit_err(span, error);
}
Ok(expr)
}
#[cfg(not(feature = "verify"))]
pub(in crate::parser) fn verify_expr(&mut self, expr: Box<Expr>) -> PResult<Box<Expr>> {
Ok(expr)
}
}
#[cfg(feature = "verify")]
pub(super) struct Verifier {
pub errors: Vec<(Span, SyntaxError)>,
}
#[cfg(feature = "verify")]
impl Visit for Verifier {
noop_visit_type!();
fn visit_assign_prop(&mut self, p: &AssignProp) {
self.errors.push((p.span(), SyntaxError::AssignProperty));
}
fn visit_expr(&mut self, e: &Expr) {
match *e {
Expr::Fn(..) | Expr::Arrow(..) => {}
_ => e.visit_children_with(self),
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/ident.rs | Rust | //! 12.1 Identifiers
use either::Either;
use swc_atoms::atom;
use super::*;
use crate::token::{IdentLike, Keyword};
impl<I: Tokens> Parser<I> {
pub(super) fn parse_maybe_private_name(&mut self) -> PResult<Either<PrivateName, IdentName>> {
let is_private = is!(self, '#');
if is_private {
self.parse_private_name().map(Either::Left)
} else {
self.parse_ident_name().map(Either::Right)
}
}
pub(super) fn parse_private_name(&mut self) -> PResult<PrivateName> {
let start = cur_pos!(self);
assert_and_bump!(self, '#');
let hash_end = self.input.prev_span().hi;
if self.input.cur_pos() - hash_end != BytePos(0) {
syntax_error!(
self,
span!(self, start),
SyntaxError::SpaceBetweenHashAndIdent
);
}
let id = self.parse_ident_name()?;
Ok(PrivateName {
span: span!(self, start),
name: id.sym,
})
}
/// IdentifierReference
pub(super) fn parse_ident_ref(&mut self) -> PResult<Ident> {
let ctx = self.ctx();
self.parse_ident(!ctx.in_generator, !ctx.in_async)
}
/// LabelIdentifier
pub(super) fn parse_label_ident(&mut self) -> PResult<Ident> {
let ctx = self.ctx();
self.parse_ident(!ctx.in_generator, !ctx.in_async)
}
/// Use this when spec says "IdentifierName".
/// This allows idents like `catch`.
pub(super) fn parse_ident_name(&mut self) -> PResult<IdentName> {
let in_type = self.ctx().in_type;
let start = cur_pos!(self);
let w = match cur!(self, true) {
Word(..) => match bump!(self) {
Word(w) => w.into(),
_ => unreachable!(),
},
Token::JSXName { .. } if in_type => match bump!(self) {
Token::JSXName { name } => name,
_ => unreachable!(),
},
_ => syntax_error!(self, SyntaxError::ExpectedIdent),
};
Ok(IdentName::new(w, span!(self, start)))
}
// https://tc39.es/ecma262/#prod-ModuleExportName
pub(super) fn parse_module_export_name(&mut self) -> PResult<ModuleExportName> {
let module_export_name = match cur!(self, false) {
Ok(&Token::Str { .. }) => match self.parse_lit()? {
Lit::Str(str_lit) => ModuleExportName::Str(str_lit),
_ => unreachable!(),
},
Ok(&Word(..)) => ModuleExportName::Ident(self.parse_ident_name()?.into()),
_ => {
unexpected!(self, "identifier or string");
}
};
Ok(module_export_name)
}
/// Identifier
///
/// In strict mode, "yield" is SyntaxError if matched.
pub(super) fn parse_ident(&mut self, incl_yield: bool, incl_await: bool) -> PResult<Ident> {
trace_cur!(self, parse_ident);
let start = cur_pos!(self);
let word = self.parse_with(|p| {
let w = match cur!(p, true) {
&Word(..) => match bump!(p) {
Word(w) => w,
_ => unreachable!(),
},
_ => syntax_error!(p, SyntaxError::ExpectedIdent),
};
// Spec:
// It is a Syntax Error if this phrase is contained in strict mode code and the
// StringValue of IdentifierName is: "implements", "interface", "let",
// "package", "private", "protected", "public", "static", or "yield".
match w {
Word::Ident(ref name @ ident_like!("enum")) => {
p.emit_err(
p.input.prev_span(),
SyntaxError::InvalidIdentInStrict(name.clone().into()),
);
}
Word::Keyword(name @ Keyword::Yield) | Word::Keyword(name @ Keyword::Let) => {
p.emit_strict_mode_err(
p.input.prev_span(),
SyntaxError::InvalidIdentInStrict(name.into_atom()),
);
}
Word::Ident(
ref name @ ident_like!("static")
| ref name @ ident_like!("implements")
| ref name @ ident_like!("interface")
| ref name @ ident_like!("package")
| ref name @ ident_like!("private")
| ref name @ ident_like!("protected")
| ref name @ ident_like!("public"),
) => {
p.emit_strict_mode_err(
p.input.prev_span(),
SyntaxError::InvalidIdentInStrict(name.clone().into()),
);
}
_ => {}
}
// Spec:
// It is a Syntax Error if StringValue of IdentifierName is the same String
// value as the StringValue of any ReservedWord except for yield or await.
match w {
Word::Keyword(Keyword::Await) if p.ctx().in_declare => Ok(atom!("await")),
Word::Keyword(Keyword::Await) if p.ctx().in_static_block => {
syntax_error!(p, p.input.prev_span(), SyntaxError::ExpectedIdent)
}
// It is a Syntax Error if the goal symbol of the syntactic grammar is Module
// and the StringValue of IdentifierName is "await".
Word::Keyword(Keyword::Await) if p.ctx().module | p.ctx().in_async => {
syntax_error!(p, p.input.prev_span(), SyntaxError::InvalidIdentInAsync)
}
Word::Keyword(Keyword::This) if p.input.syntax().typescript() => Ok(atom!("this")),
Word::Keyword(Keyword::Let) => Ok(atom!("let")),
Word::Ident(ident) => {
if matches!(&ident, IdentLike::Other(arguments) if &**arguments == "arguments")
&& p.ctx().in_class_field
{
p.emit_err(p.input.prev_span(), SyntaxError::ArgumentsInClassField)
}
Ok(ident.into())
}
Word::Keyword(Keyword::Yield) if incl_yield => Ok(atom!("yield")),
Word::Keyword(Keyword::Await) if incl_await => Ok(atom!("await")),
Word::Keyword(..) | Word::Null | Word::True | Word::False => {
syntax_error!(p, p.input.prev_span(), SyntaxError::ExpectedIdent)
}
}
})?;
Ok(Ident::new_no_ctxt(word, span!(self, start)))
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/input.rs | Rust | use std::{cell::RefCell, mem, mem::take, rc::Rc};
use debug_unreachable::debug_unreachable;
use lexer::TokenContexts;
use swc_common::{BytePos, Span};
use super::Parser;
use crate::{
error::Error,
lexer::{self},
token::*,
Context, EsVersion, Syntax,
};
/// Clone should be cheap if you are parsing typescript because typescript
/// syntax requires backtracking.
pub trait Tokens: Clone + Iterator<Item = TokenAndSpan> {
fn set_ctx(&mut self, ctx: Context);
fn ctx(&self) -> Context;
fn syntax(&self) -> Syntax;
fn target(&self) -> EsVersion;
fn start_pos(&self) -> BytePos {
BytePos(0)
}
fn set_expr_allowed(&mut self, allow: bool);
fn set_next_regexp(&mut self, start: Option<BytePos>);
fn token_context(&self) -> &lexer::TokenContexts;
fn token_context_mut(&mut self) -> &mut lexer::TokenContexts;
fn set_token_context(&mut self, _c: lexer::TokenContexts);
/// Implementors should use Rc<RefCell<Vec<Error>>>.
///
/// It is required because parser should backtrack while parsing typescript
/// code.
fn add_error(&self, error: Error);
/// Add an error which is valid syntax in script mode.
///
/// This errors should be dropped if it's not a module.
///
/// Implementor should check for if [Context].module, and buffer errors if
/// module is false. Also, implementors should move errors to the error
/// buffer on set_ctx if the parser mode become module mode.
fn add_module_mode_error(&self, error: Error);
fn end_pos(&self) -> BytePos;
fn take_errors(&mut self) -> Vec<Error>;
/// If the program was parsed as a script, this contains the module
/// errors should the program be identified as a module in the future.
fn take_script_module_errors(&mut self) -> Vec<Error>;
}
#[derive(Clone)]
pub struct TokensInput {
iter: <Vec<TokenAndSpan> as IntoIterator>::IntoIter,
ctx: Context,
syntax: Syntax,
start_pos: BytePos,
target: EsVersion,
token_ctx: TokenContexts,
errors: Rc<RefCell<Vec<Error>>>,
module_errors: Rc<RefCell<Vec<Error>>>,
}
impl TokensInput {
pub fn new(tokens: Vec<TokenAndSpan>, ctx: Context, syntax: Syntax, target: EsVersion) -> Self {
let start_pos = tokens.first().map(|t| t.span.lo).unwrap_or(BytePos(0));
TokensInput {
iter: tokens.into_iter(),
ctx,
syntax,
start_pos,
target,
token_ctx: Default::default(),
errors: Default::default(),
module_errors: Default::default(),
}
}
}
impl Iterator for TokensInput {
type Item = TokenAndSpan;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
impl Tokens for TokensInput {
fn set_ctx(&mut self, ctx: Context) {
if ctx.module && !self.module_errors.borrow().is_empty() {
let mut module_errors = self.module_errors.borrow_mut();
self.errors.borrow_mut().append(&mut *module_errors);
}
self.ctx = ctx;
}
fn ctx(&self) -> Context {
self.ctx
}
fn syntax(&self) -> Syntax {
self.syntax
}
fn target(&self) -> EsVersion {
self.target
}
fn start_pos(&self) -> BytePos {
self.start_pos
}
fn set_expr_allowed(&mut self, _: bool) {}
fn set_next_regexp(&mut self, _: Option<BytePos>) {}
fn token_context(&self) -> &TokenContexts {
&self.token_ctx
}
fn token_context_mut(&mut self) -> &mut TokenContexts {
&mut self.token_ctx
}
fn set_token_context(&mut self, c: TokenContexts) {
self.token_ctx = c;
}
fn add_error(&self, error: Error) {
self.errors.borrow_mut().push(error);
}
fn add_module_mode_error(&self, error: Error) {
if self.ctx.module {
self.add_error(error);
return;
}
self.module_errors.borrow_mut().push(error);
}
fn take_errors(&mut self) -> Vec<Error> {
take(&mut self.errors.borrow_mut())
}
fn take_script_module_errors(&mut self) -> Vec<Error> {
take(&mut self.module_errors.borrow_mut())
}
fn end_pos(&self) -> BytePos {
self.iter
.as_slice()
.last()
.map(|t| t.span.hi)
.unwrap_or(self.start_pos)
}
}
/// Note: Lexer need access to parser's context to lex correctly.
#[derive(Debug)]
pub struct Capturing<I: Tokens> {
inner: I,
captured: Rc<RefCell<Vec<TokenAndSpan>>>,
}
impl<I: Tokens> Clone for Capturing<I> {
fn clone(&self) -> Self {
Capturing {
inner: self.inner.clone(),
captured: self.captured.clone(),
}
}
}
impl<I: Tokens> Capturing<I> {
pub fn new(input: I) -> Self {
Capturing {
inner: input,
captured: Default::default(),
}
}
pub fn tokens(&self) -> Rc<RefCell<Vec<TokenAndSpan>>> {
self.captured.clone()
}
/// Take captured tokens
pub fn take(&mut self) -> Vec<TokenAndSpan> {
mem::take(&mut *self.captured.borrow_mut())
}
}
impl<I: Tokens> Iterator for Capturing<I> {
type Item = TokenAndSpan;
fn next(&mut self) -> Option<Self::Item> {
let next = self.inner.next();
match next {
Some(ts) => {
let mut v = self.captured.borrow_mut();
// remove tokens that could change due to backtracing
while let Some(last) = v.last() {
if last.span.lo >= ts.span.lo {
v.pop();
} else {
break;
}
}
v.push(ts.clone());
Some(ts)
}
None => None,
}
}
}
impl<I: Tokens> Tokens for Capturing<I> {
fn set_ctx(&mut self, ctx: Context) {
self.inner.set_ctx(ctx)
}
fn ctx(&self) -> Context {
self.inner.ctx()
}
fn syntax(&self) -> Syntax {
self.inner.syntax()
}
fn target(&self) -> EsVersion {
self.inner.target()
}
fn start_pos(&self) -> BytePos {
self.inner.start_pos()
}
fn set_expr_allowed(&mut self, allow: bool) {
self.inner.set_expr_allowed(allow)
}
fn set_next_regexp(&mut self, start: Option<BytePos>) {
self.inner.set_next_regexp(start);
}
fn token_context(&self) -> &TokenContexts {
self.inner.token_context()
}
fn token_context_mut(&mut self) -> &mut TokenContexts {
self.inner.token_context_mut()
}
fn set_token_context(&mut self, c: TokenContexts) {
self.inner.set_token_context(c)
}
fn add_error(&self, error: Error) {
self.inner.add_error(error);
}
fn add_module_mode_error(&self, error: Error) {
self.inner.add_module_mode_error(error)
}
fn take_errors(&mut self) -> Vec<Error> {
self.inner.take_errors()
}
fn take_script_module_errors(&mut self) -> Vec<Error> {
self.inner.take_script_module_errors()
}
fn end_pos(&self) -> BytePos {
self.inner.end_pos()
}
}
/// This struct is responsible for managing current token and peeked token.
#[derive(Clone)]
pub(super) struct Buffer<I: Tokens> {
iter: I,
/// Span of the previous token.
prev_span: Span,
cur: Option<TokenAndSpan>,
/// Peeked token
next: Option<TokenAndSpan>,
}
impl<I: Tokens> Parser<I> {
pub fn input(&mut self) -> &mut I {
&mut self.input.iter
}
pub(crate) fn input_ref(&self) -> &I {
&self.input.iter
}
}
impl<I: Tokens> Buffer<I> {
pub fn new(lexer: I) -> Self {
let start_pos = lexer.start_pos();
Buffer {
iter: lexer,
cur: None,
prev_span: Span::new(start_pos, start_pos),
next: None,
}
}
pub fn store(&mut self, token: Token) {
debug_assert!(self.next.is_none());
debug_assert!(self.cur.is_none());
let span = self.prev_span;
self.cur = Some(TokenAndSpan {
span,
token,
had_line_break: false,
});
}
#[allow(dead_code)]
pub fn cur_debug(&self) -> Option<&Token> {
self.cur.as_ref().map(|it| &it.token)
}
#[cold]
#[inline(never)]
pub fn dump_cur(&mut self) -> String {
match self.cur() {
Some(v) => format!("{:?}", v),
None => "<eof>".to_string(),
}
}
/// Returns current token.
pub fn bump(&mut self) -> Token {
let prev = match self.cur.take() {
Some(t) => t,
None => unsafe {
debug_unreachable!(
"Current token is `None`. Parser should not call bump() without knowing \
current token"
)
},
};
self.prev_span = prev.span;
prev.token
}
pub fn knows_cur(&self) -> bool {
self.cur.is_some()
}
pub fn peek(&mut self) -> Option<&Token> {
debug_assert!(
self.cur.is_some(),
"parser should not call peek() without knowing current token"
);
if self.next.is_none() {
self.next = self.iter.next();
}
self.next.as_ref().map(|ts| &ts.token)
}
/// Returns true on eof.
pub fn had_line_break_before_cur(&mut self) -> bool {
self.cur();
self.cur
.as_ref()
.map(|it| it.had_line_break)
.unwrap_or_else(|| true)
}
/// This returns true on eof.
pub fn has_linebreak_between_cur_and_peeked(&mut self) -> bool {
let _ = self.peek();
self.next
.as_ref()
.map(|item| item.had_line_break)
.unwrap_or({
// return true on eof.
true
})
}
/// Get current token. Returns `None` only on eof.
#[inline]
pub fn cur(&mut self) -> Option<&Token> {
if self.cur.is_none() {
// If we have peeked a token, take it instead of calling lexer.next()
self.cur = self.next.take().or_else(|| self.iter.next());
}
match &self.cur {
Some(v) => Some(&v.token),
None => None,
}
}
#[inline]
pub fn cut_lshift(&mut self) {
debug_assert!(
self.is(&tok!("<<")),
"parser should only call cut_lshift when encountering LShift token"
);
self.cur = Some(TokenAndSpan {
token: tok!('<'),
span: self.cur_span().with_lo(self.cur_span().lo + BytePos(1)),
had_line_break: false,
});
}
pub fn merge_lt_gt(&mut self) {
debug_assert!(
self.is(&tok!('<')) || self.is(&tok!('>')),
"parser should only call merge_lt_gt when encountering '<' or '>' token"
);
let span = self.cur_span();
if self.peek().is_none() {
return;
}
let next = self.next.as_ref().unwrap();
if span.hi != next.span.lo {
return;
}
let cur = self.cur.take().unwrap();
let next = self.next.take().unwrap();
let token = match (&cur.token, &next.token) {
(tok!('>'), tok!('>')) => tok!(">>"),
(tok!('>'), tok!('=')) => tok!(">="),
(tok!('>'), tok!(">>")) => tok!(">>>"),
(tok!('>'), tok!(">=")) => tok!(">>="),
(tok!('>'), tok!(">>=")) => tok!(">>>="),
(tok!('<'), tok!('<')) => tok!("<<"),
(tok!('<'), tok!('=')) => tok!("<="),
(tok!('<'), tok!("<=")) => tok!("<<="),
_ => {
self.cur = Some(cur);
self.next = Some(next);
return;
}
};
let span = span.with_hi(next.span.hi);
self.cur = Some(TokenAndSpan {
token,
span,
had_line_break: cur.had_line_break,
});
}
#[inline]
pub fn is(&mut self, expected: &Token) -> bool {
match self.cur() {
Some(t) => *expected == *t,
_ => false,
}
}
#[inline]
pub fn eat(&mut self, expected: &Token) -> bool {
let v = self.is(expected);
if v {
self.bump();
}
v
}
/// Returns start of current token.
#[inline]
pub fn cur_pos(&mut self) -> BytePos {
let _ = self.cur();
self.cur
.as_ref()
.map(|item| item.span.lo)
.unwrap_or_else(|| {
// eof
self.last_pos()
})
}
#[inline]
pub fn cur_span(&self) -> Span {
let data = self
.cur
.as_ref()
.map(|item| item.span)
.unwrap_or(self.prev_span);
Span::new(data.lo, data.hi)
}
/// Returns last byte position of previous token.
#[inline]
pub fn last_pos(&self) -> BytePos {
self.prev_span.hi
}
/// Returns span of the previous token.
#[inline]
pub fn prev_span(&self) -> Span {
self.prev_span
}
#[inline]
pub(crate) fn get_ctx(&self) -> Context {
self.iter.ctx()
}
#[inline]
pub(crate) fn set_ctx(&mut self, ctx: Context) {
self.iter.set_ctx(ctx);
}
#[inline]
pub fn syntax(&self) -> Syntax {
self.iter.syntax()
}
#[inline]
pub fn target(&self) -> EsVersion {
self.iter.target()
}
#[inline]
pub(crate) fn set_expr_allowed(&mut self, allow: bool) {
self.iter.set_expr_allowed(allow)
}
#[inline]
pub fn set_next_regexp(&mut self, start: Option<BytePos>) {
self.iter.set_next_regexp(start);
}
#[inline]
pub(crate) fn token_context(&self) -> &lexer::TokenContexts {
self.iter.token_context()
}
#[inline]
pub(crate) fn token_context_mut(&mut self) -> &mut lexer::TokenContexts {
self.iter.token_context_mut()
}
#[inline]
pub(crate) fn set_token_context(&mut self, c: lexer::TokenContexts) {
self.iter.set_token_context(c)
}
#[inline]
pub(crate) fn end_pos(&self) -> BytePos {
self.iter.end_pos()
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/jsx.rs | Rust | use either::Either;
use swc_common::Spanned;
use super::*;
#[cfg(test)]
mod tests;
impl<I: Tokens> Parser<I> {
/// Parse next token as JSX identifier
pub(super) fn parse_jsx_ident(&mut self) -> PResult<Ident> {
debug_assert!(self.input.syntax().jsx());
trace_cur!(self, parse_jsx_ident);
let ctx = self.ctx();
match *cur!(self, true) {
Token::JSXName { .. } => match bump!(self) {
Token::JSXName { name } => {
let span = self.input.prev_span();
Ok(Ident::new_no_ctxt(name, span))
}
_ => unreachable!(),
},
_ if ctx.in_forced_jsx_context => self.parse_ident_ref(),
_ => unexpected!(self, "jsx identifier"),
}
}
/// Parse namespaced identifier.
pub(super) fn parse_jsx_namespaced_name(&mut self) -> PResult<JSXAttrName> {
debug_assert!(self.input.syntax().jsx());
trace_cur!(self, parse_jsx_namespaced_name);
let start = cur_pos!(self);
let ns = self.parse_jsx_ident()?.into();
if !eat!(self, ':') {
return Ok(JSXAttrName::Ident(ns));
}
let name = self.parse_jsx_ident().map(IdentName::from)?;
Ok(JSXAttrName::JSXNamespacedName(JSXNamespacedName {
span: Span::new(start, name.span.hi),
ns,
name,
}))
}
/// Parses element name in any form - namespaced, member or single
/// identifier.
pub(super) fn parse_jsx_element_name(&mut self) -> PResult<JSXElementName> {
debug_assert!(self.input.syntax().jsx());
trace_cur!(self, parse_jsx_element_name);
let start = cur_pos!(self);
let mut node = match self.parse_jsx_namespaced_name()? {
JSXAttrName::Ident(i) => JSXElementName::Ident(i.into()),
JSXAttrName::JSXNamespacedName(i) => JSXElementName::JSXNamespacedName(i),
};
while eat!(self, '.') {
let prop = self.parse_jsx_ident().map(IdentName::from)?;
let new_node = JSXElementName::JSXMemberExpr(JSXMemberExpr {
span: span!(self, start),
obj: match node {
JSXElementName::Ident(i) => JSXObject::Ident(i),
JSXElementName::JSXMemberExpr(i) => JSXObject::JSXMemberExpr(Box::new(i)),
_ => unimplemented!("JSXNamespacedName -> JSXObject"),
},
prop,
});
node = new_node;
}
Ok(node)
}
/// Parses any type of JSX attribute value.
///
/// TODO(kdy1): Change return type to JSXAttrValue
pub(super) fn parse_jsx_attr_value(&mut self) -> PResult<JSXAttrValue> {
debug_assert!(self.input.syntax().jsx());
trace_cur!(self, parse_jsx_attr_value);
let start = cur_pos!(self);
match *cur!(self, true) {
tok!('{') => {
let node = self.parse_jsx_expr_container(start)?;
match node.expr {
JSXExpr::JSXEmptyExpr(..) => {
syntax_error!(self, span!(self, start), SyntaxError::EmptyJSXAttr)
}
JSXExpr::Expr(..) => Ok(node.into()),
}
}
Token::Str { .. } => {
let lit = self.parse_lit()?;
Ok(JSXAttrValue::Lit(lit))
}
Token::JSXTagStart => {
let expr = self.parse_jsx_element()?;
match expr {
Either::Left(n) => Ok(JSXAttrValue::JSXFragment(n)),
Either::Right(n) => Ok(JSXAttrValue::JSXElement(Box::new(n))),
}
}
_ => {
let span = self.input.cur_span();
syntax_error!(self, span, SyntaxError::InvalidJSXValue)
}
}
}
/// JSXEmptyExpression is unique type since it doesn't actually parse
/// anything, and so it should start at the end of last read token (left
/// brace) and finish at the beginning of the next one (right brace).
pub(super) fn parse_jsx_empty_expr(&mut self) -> PResult<JSXEmptyExpr> {
debug_assert!(self.input.syntax().jsx());
let start = cur_pos!(self);
Ok(JSXEmptyExpr {
span: Span::new(start, start),
})
}
/// Parse JSX spread child
pub(super) fn parse_jsx_spread_child(&mut self) -> PResult<JSXSpreadChild> {
debug_assert!(self.input.syntax().jsx());
let start = cur_pos!(self);
expect!(self, '{');
expect!(self, "...");
let expr = self.parse_expr()?;
expect!(self, '}');
Ok(JSXSpreadChild {
span: span!(self, start),
expr,
})
}
/// Parses JSX expression enclosed into curly brackets.
pub(super) fn parse_jsx_expr_container(&mut self, _: BytePos) -> PResult<JSXExprContainer> {
debug_assert!(self.input.syntax().jsx());
let start = cur_pos!(self);
bump!(self);
let expr = if is!(self, '}') {
self.parse_jsx_empty_expr().map(JSXExpr::JSXEmptyExpr)?
} else {
if is!(self, "...") {
bump!(self);
}
self.parse_expr().map(JSXExpr::Expr)?
};
expect!(self, '}');
Ok(JSXExprContainer {
span: span!(self, start),
expr,
})
}
/// Parses following JSX attribute name-value pair.
pub(super) fn parse_jsx_attr(&mut self) -> PResult<JSXAttrOrSpread> {
debug_assert!(self.input.syntax().jsx());
let start = cur_pos!(self);
let _tracing = debug_tracing!(self, "parse_jsx_attr");
if eat!(self, '{') {
let dot3_start = cur_pos!(self);
expect!(self, "...");
let dot3_token = span!(self, dot3_start);
let expr = self.parse_assignment_expr()?;
expect!(self, '}');
return Ok(SpreadElement { dot3_token, expr }.into());
}
let name = self.parse_jsx_namespaced_name()?;
let value = if eat!(self, '=') {
let ctx = Context {
in_cond_expr: false,
will_expect_colon_for_cond: false,
..self.ctx()
};
self.with_ctx(ctx).parse_jsx_attr_value().map(Some)?
} else {
None
};
Ok(JSXAttr {
span: span!(self, start),
name,
value,
}
.into())
}
/// Parses JSX opening tag starting after "<".
pub(super) fn parse_jsx_opening_element_at(
&mut self,
start: BytePos,
) -> PResult<Either<JSXOpeningFragment, JSXOpeningElement>> {
debug_assert!(self.input.syntax().jsx());
if eat!(self, JSXTagEnd) {
return Ok(Either::Left(JSXOpeningFragment {
span: span!(self, start),
}));
}
let ctx = Context {
should_not_lex_lt_or_gt_as_type: false,
..self.ctx()
};
let name = self.with_ctx(ctx).parse_jsx_element_name()?;
self.parse_jsx_opening_element_after_name(start, name)
.map(Either::Right)
}
/// `jsxParseOpeningElementAfterName`
pub(super) fn parse_jsx_opening_element_after_name(
&mut self,
start: BytePos,
name: JSXElementName,
) -> PResult<JSXOpeningElement> {
debug_assert!(self.input.syntax().jsx());
let type_args = if self.input.syntax().typescript() && is!(self, '<') {
self.try_parse_ts(|p| p.parse_ts_type_args().map(Some))
} else {
None
};
let mut attrs = Vec::new();
while cur!(self, false).is_ok() {
trace_cur!(self, parse_jsx_opening__attrs_loop);
if is!(self, '/') || is!(self, JSXTagEnd) {
break;
}
let attr = self.parse_jsx_attr()?;
attrs.push(attr);
}
let self_closing = eat!(self, '/');
if !eat!(self, JSXTagEnd) & !(self.ctx().in_forced_jsx_context && eat!(self, '>')) {
unexpected!(self, "> (jsx closing tag)");
}
Ok(JSXOpeningElement {
span: span!(self, start),
name,
attrs,
self_closing,
type_args,
})
}
/// Parses JSX closing tag starting after "</".
fn parse_jsx_closing_element_at(
&mut self,
start: BytePos,
) -> PResult<Either<JSXClosingFragment, JSXClosingElement>> {
debug_assert!(self.input.syntax().jsx());
if eat!(self, JSXTagEnd) {
return Ok(Either::Left(JSXClosingFragment {
span: span!(self, start),
}));
}
let name = self.parse_jsx_element_name()?;
expect!(self, JSXTagEnd);
Ok(Either::Right(JSXClosingElement {
span: span!(self, start),
name,
}))
}
/// Parses entire JSX element, including it"s opening tag
/// (starting after "<"), attributes, contents and closing tag.
///
/// babel: `jsxParseElementAt`
pub(super) fn parse_jsx_element_at(
&mut self,
start_pos: BytePos,
) -> PResult<Either<JSXFragment, JSXElement>> {
debug_assert!(self.input.syntax().jsx());
let _ = cur!(self, true);
let start = cur_pos!(self);
let forced_jsx_context = match bump!(self) {
tok!('<') => true,
Token::JSXTagStart => false,
_ => unreachable!(),
};
let ctx = Context {
in_forced_jsx_context: forced_jsx_context,
should_not_lex_lt_or_gt_as_type: false,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
let _tracing = debug_tracing!(p, "parse_jsx_element");
let opening_element = p.parse_jsx_opening_element_at(start_pos)?;
trace_cur!(p, parse_jsx_element__after_opening_element);
let mut children = Vec::new();
let mut closing_element = None;
let self_closing = match opening_element {
Either::Right(ref el) => el.self_closing,
_ => false,
};
if !self_closing {
'contents: loop {
match *cur!(p, true) {
Token::JSXTagStart => {
let start = cur_pos!(p);
if peeked_is!(p, '/') {
bump!(p); // JSXTagStart
let _ = cur!(p, true);
assert_and_bump!(p, '/');
closing_element =
p.parse_jsx_closing_element_at(start).map(Some)?;
break 'contents;
}
children.push(p.parse_jsx_element_at(start).map(|e| match e {
Either::Left(e) => JSXElementChild::from(e),
Either::Right(e) => JSXElementChild::from(Box::new(e)),
})?);
}
Token::JSXText { .. } => {
children.push(p.parse_jsx_text().map(JSXElementChild::from)?)
}
tok!('{') => {
let start = cur_pos!(p);
if peeked_is!(p, "...") {
children
.push(p.parse_jsx_spread_child().map(JSXElementChild::from)?);
} else {
children.push(
p.parse_jsx_expr_container(start)
.map(JSXElementChild::from)?,
);
}
}
_ => unexpected!(p, "< (jsx tag start), jsx text or {"),
}
}
}
let span = span!(p, start);
Ok(match (opening_element, closing_element) {
(Either::Left(..), Some(Either::Right(closing))) => {
syntax_error!(p, closing.span(), SyntaxError::JSXExpectedClosingTagForLtGt);
}
(Either::Right(opening), Some(Either::Left(closing))) => {
syntax_error!(
p,
closing.span(),
SyntaxError::JSXExpectedClosingTag {
tag: get_qualified_jsx_name(&opening.name)
}
);
}
(Either::Left(opening), Some(Either::Left(closing))) => Either::Left(JSXFragment {
span,
opening,
children,
closing,
}),
(Either::Right(opening), None) => Either::Right(JSXElement {
span,
opening,
children,
closing: None,
}),
(Either::Right(opening), Some(Either::Right(closing))) => {
if get_qualified_jsx_name(&closing.name)
!= get_qualified_jsx_name(&opening.name)
{
syntax_error!(
p,
closing.span(),
SyntaxError::JSXExpectedClosingTag {
tag: get_qualified_jsx_name(&opening.name)
}
);
}
Either::Right(JSXElement {
span,
opening,
children,
closing: Some(closing),
})
}
_ => unreachable!(),
})
})
}
/// Parses entire JSX element from current position.
///
/// babel: `jsxParseElement`
pub(super) fn parse_jsx_element(&mut self) -> PResult<Either<JSXFragment, JSXElement>> {
trace_cur!(self, parse_jsx_element);
debug_assert!(self.input.syntax().jsx());
debug_assert!({ matches!(*cur!(self, true), Token::JSXTagStart | tok!('<')) });
let start_pos = cur_pos!(self);
let ctx = Context {
in_cond_expr: false,
will_expect_colon_for_cond: false,
..self.ctx()
};
self.with_ctx(ctx).parse_jsx_element_at(start_pos)
}
pub(super) fn parse_jsx_text(&mut self) -> PResult<JSXText> {
debug_assert!(self.input.syntax().jsx());
debug_assert!(matches!(cur!(self, false), Ok(&Token::JSXText { .. })));
let token = bump!(self);
let span = self.input.prev_span();
match token {
Token::JSXText { raw, value } => Ok(JSXText { span, value, raw }),
_ => unreachable!(),
}
}
}
fn get_qualified_jsx_name(name: &JSXElementName) -> Atom {
fn get_qualified_obj_name(obj: &JSXObject) -> Atom {
match *obj {
JSXObject::Ident(ref i) => i.sym.clone(),
JSXObject::JSXMemberExpr(ref member) => format!(
"{}.{}",
get_qualified_obj_name(&member.obj),
member.prop.sym
)
.into(),
}
}
match *name {
JSXElementName::Ident(ref i) => i.sym.clone(),
JSXElementName::JSXNamespacedName(JSXNamespacedName {
ref ns, ref name, ..
}) => format!("{}:{}", ns.sym, name.sym).into(),
JSXElementName::JSXMemberExpr(JSXMemberExpr {
ref obj, ref prop, ..
}) => format!("{}.{}", get_qualified_obj_name(obj), prop.sym).into(),
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/jsx/tests.rs | Rust | use swc_common::DUMMY_SP as span;
use swc_ecma_visit::assert_eq_ignore_span;
use super::*;
fn jsx(src: &'static str) -> Box<Expr> {
test_parser(
src,
crate::Syntax::Es(crate::EsSyntax {
jsx: true,
..Default::default()
}),
|p| p.parse_expr(),
)
}
#[test]
fn self_closing_01() {
assert_eq_ignore_span!(
jsx("<a />"),
Box::new(Expr::JSXElement(Box::new(JSXElement {
span,
opening: JSXOpeningElement {
span,
name: JSXElementName::Ident(Ident::new_no_ctxt("a".into(), span)),
self_closing: true,
attrs: Vec::new(),
type_args: None,
},
children: Vec::new(),
closing: None,
})))
);
}
#[test]
fn normal_01() {
assert_eq_ignore_span!(
jsx("<a>foo</a>"),
Box::new(Expr::JSXElement(Box::new(JSXElement {
span,
opening: JSXOpeningElement {
span,
name: JSXElementName::Ident(Ident::new_no_ctxt("a".into(), span)),
self_closing: false,
attrs: Vec::new(),
type_args: None,
},
children: vec![JSXElementChild::JSXText(JSXText {
span,
raw: "foo".into(),
value: "foo".into(),
})],
closing: Some(JSXClosingElement {
span,
name: JSXElementName::Ident(Ident::new_no_ctxt("a".into(), span)),
})
})))
);
}
#[test]
fn escape_in_attr() {
assert_eq_ignore_span!(
jsx(r#"<div id="w < w" />;"#),
Box::new(Expr::JSXElement(Box::new(JSXElement {
span,
opening: JSXOpeningElement {
span,
attrs: vec![JSXAttrOrSpread::JSXAttr(JSXAttr {
span,
name: JSXAttrName::Ident(IdentName::new("id".into(), span)),
value: Some(JSXAttrValue::Lit(Lit::Str(Str {
span,
value: "w < w".into(),
raw: Some("\"w < w\"".into()),
}))),
})],
name: JSXElementName::Ident(Ident::new_no_ctxt("div".into(), span)),
self_closing: true,
type_args: None,
},
children: Vec::new(),
closing: None
})))
);
}
#[test]
fn issue_584() {
assert_eq_ignore_span!(
jsx(r#"<test other={4} />;"#),
Box::new(Expr::JSXElement(Box::new(JSXElement {
span,
opening: JSXOpeningElement {
span,
name: JSXElementName::Ident(Ident::new_no_ctxt("test".into(), span)),
attrs: vec![JSXAttrOrSpread::JSXAttr(JSXAttr {
span,
name: JSXAttrName::Ident(IdentName::new("other".into(), span)),
value: Some(JSXAttrValue::JSXExprContainer(JSXExprContainer {
span,
expr: JSXExpr::Expr(Box::new(Expr::Lit(Lit::Num(Number {
span,
value: 4.0,
raw: Some("4".into())
}))))
})),
})],
self_closing: true,
type_args: None,
},
children: Vec::new(),
closing: None
})))
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/macros.rs | Rust | macro_rules! unexpected {
($p:expr, $expected:literal) => {{
let got = $p.input.dump_cur();
syntax_error!(
$p,
$p.input.cur_span(),
SyntaxError::Unexpected {
got,
expected: $expected
}
)
}};
}
/// This handles automatic semicolon insertion.
///
/// Returns bool.
macro_rules! is {
($p:expr, BindingIdent) => {{
let ctx = $p.ctx();
match $p.input.cur() {
Some(&Word(ref w)) => !ctx.is_reserved(w),
_ => false,
}
}};
($p:expr, IdentRef) => {{
let ctx = $p.ctx();
match $p.input.cur() {
Some(&Word(ref w)) => !ctx.is_reserved(w),
_ => false,
}
}};
($p:expr,IdentName) => {{
match $p.input.cur() {
Some(&Word(..)) => true,
_ => false,
}
}};
($p:expr,Str) => {{
match $p.input.cur() {
Some(&Token::Str { .. }) => true,
_ => false,
}
}};
($p:expr,Num) => {{
match $p.input.cur() {
Some(&Token::Num { .. }) => true,
_ => false,
}
}};
($p:expr,Regex) => {{
match $p.input.cur() {
Some(&Token::Regex { .. }) => true,
_ => false,
}
}};
($p:expr,BigInt) => {{
match $p.input.cur() {
Some(&Token::BigInt { .. }) => true,
_ => false,
}
}};
($p:expr,';') => {{
match $p.input.cur() {
Some(&Token::Semi) | None | Some(&tok!('}')) => true,
_ => $p.input.had_line_break_before_cur(),
}
}};
($p:expr, $t:tt) => {
is_exact!($p, $t)
};
}
#[allow(unused)]
macro_rules! peeked_is {
($p:expr, BindingIdent) => {{
let ctx = $p.ctx();
match peek!($p) {
Some(&Word(ref w)) => !ctx.is_reserved(w),
_ => false,
}
}};
($p:expr, IdentRef) => {{
let ctx = $p.ctx();
match peek!($p) {
Some(&Word(ref w)) => !ctx.is_reserved(w),
_ => false,
}
}};
($p:expr,IdentName) => {{
match peek!($p) {
Some(&Word(..)) => true,
_ => false,
}
}};
($p:expr, JSXName) => {{
match peek!($p) {
Some(&Token::JSXName { .. }) => true,
_ => false,
}
}};
($p:expr, ';') => {{
compile_error!("peeked_is!(self, ';') is invalid");
}};
($p:expr, $t:tt) => {
match peek!($p) {
Some(&token_including_semi!($t)) => true,
_ => false,
}
};
}
/// Returns true on eof.
macro_rules! eof {
($p:expr) => {
cur!($p, false).is_err()
};
}
macro_rules! is_one_of {
($p:expr, $($t:tt),+) => {{
false
$(
|| is!($p, $t)
)*
}};
}
// This will panic if current != token
macro_rules! assert_and_bump {
($p:expr, $t:tt) => {{
const TOKEN: &Token = &tok!($t);
if cfg!(debug_assertions) && !is!($p, $t) {
unreachable!(
"assertion failed: expected {:?}, got {:?}",
TOKEN,
$p.input.cur()
);
}
let _ = cur!($p, true);
bump!($p);
}};
}
/// This handles automatic semicolon insertion.
///
/// Returns bool if token is static, and Option<Token>
/// if token has data like string.
macro_rules! eat {
($p:expr, ';') => {{
if cfg!(feature = "debug") {
tracing::trace!("eat(';'): cur={:?}", cur!($p, false));
}
match $p.input.cur() {
Some(&Token::Semi) => {
$p.input.bump();
true
}
None | Some(&tok!('}')) => true,
_ => $p.input.had_line_break_before_cur(),
}
}};
($p:expr, $t:tt) => {{
if is!($p, $t) {
bump!($p);
true
} else {
false
}
}};
}
macro_rules! eat_exact {
($p:expr, $t:tt) => {{
if is_exact!($p, $t) {
bump!($p);
true
} else {
false
}
}};
}
macro_rules! is_exact {
($p:expr, $t:tt) => {{
match $p.input.cur() {
Some(&token_including_semi!($t)) => true,
_ => false,
}
}};
}
/// This handles automatic semicolon insertion.
macro_rules! expect {
($p:expr, $t:tt) => {{
const TOKEN: &Token = &token_including_semi!($t);
if !eat!($p, $t) {
let cur = $p.input.dump_cur();
syntax_error!($p, $p.input.cur_span(), SyntaxError::Expected(TOKEN, cur))
}
}};
}
macro_rules! expect_exact {
($p:expr, $t:tt) => {{
const TOKEN: &Token = &token_including_semi!($t);
if !eat_exact!($p, $t) {
let cur = $p.input.dump_cur();
syntax_error!($p, $p.input.cur_span(), SyntaxError::Expected(TOKEN, cur))
}
}};
}
macro_rules! store {
($p:expr, $t:tt) => {{
const TOKEN: Token = token_including_semi!($t);
$p.input.store(TOKEN);
}};
}
/// cur!($parser, required:bool)
macro_rules! cur {
($p:expr, false) => {{
match $p.input.cur() {
Some(c) => Ok(c),
None => {
let pos = $p.input.end_pos();
let last = Span::new(pos, pos);
Err(crate::error::Error::new(
last,
crate::error::SyntaxError::Eof,
))
}
}
}};
($p:expr, true) => {{
match $p.input.cur() {
Some(c) => match c {
Token::Error(..) => match $p.input.bump() {
$crate::token::Token::Error(e) => {
return Err(e);
}
_ => unreachable!(),
},
_ => c,
},
None => {
let pos = $p.input.end_pos();
let span = Span::new(pos, pos);
let err = crate::error::Error::new(span, crate::error::SyntaxError::Eof);
return Err(err);
}
}
}};
}
macro_rules! peek {
($p:expr) => {{
debug_assert!(
$p.input.knows_cur(),
"parser should not call peek() without knowing current token.
Current token is {:?}",
cur!($p, false),
);
$p.input.peek()
}};
}
macro_rules! bump {
($p:expr) => {{
debug_assert!(
$p.input.knows_cur(),
"parser should not call bump() without knowing current token"
);
$p.input.bump()
}};
}
macro_rules! cur_pos {
($p:expr) => {{
$p.input.cur_pos()
}};
}
macro_rules! last_pos {
($p:expr) => {
$p.input.prev_span().hi
};
}
macro_rules! return_if_arrow {
($p:expr, $expr:expr) => {{
// FIXME:
//
//
// let is_cur = match $p.state.potential_arrow_start {
// Some(start) => $expr.span.lo() == start,
// None => false
// };
// if is_cur {
if let Expr::Arrow { .. } = *$expr {
return Ok($expr);
}
// }
}};
}
macro_rules! trace_cur {
($p:expr, $name:ident) => {{
if cfg!(feature = "debug") {
tracing::debug!("{}: {:?}", stringify!($name), $p.input.cur());
}
}};
}
/// This macro requires macro named 'last_pos' to be in scope.
macro_rules! span {
($p:expr, $start:expr) => {{
let start: ::swc_common::BytePos = $start;
let end: ::swc_common::BytePos = last_pos!($p);
if cfg!(debug_assertions) && start > end {
unreachable!(
"assertion failed: (span.start <= span.end).
start = {}, end = {}",
start.0, end.0
)
}
::swc_common::Span::new(start, end)
}};
}
macro_rules! make_error {
($p:expr, $span:expr, $err:expr) => {{
crate::error::Error::new($span, $err)
}};
}
macro_rules! syntax_error {
($p:expr, $err:expr) => {
syntax_error!($p, $p.input.cur_span(), $err)
};
($p:expr, $span:expr, $err:expr) => {{
let err = make_error!($p, $span, $err);
{
let is_err_token = match $p.input.cur() {
Some(&$crate::token::Token::Error(..)) => true,
_ => false,
};
if is_err_token {
match $p.input.bump() {
$crate::token::Token::Error(e) => {
$p.emit_error(e);
}
_ => unreachable!(),
}
}
}
if cfg!(feature = "debug") {
tracing::error!(
"Syntax error called from {}:{}:{}\nCurrent token = {:?}",
file!(),
line!(),
column!(),
$p.input.cur()
);
}
return Err(err.into());
}};
}
macro_rules! debug_tracing {
($p:expr, $name:tt) => {{
#[cfg(feature = "debug")]
{
tracing::span!(
tracing::Level::ERROR,
$name,
cur = tracing::field::debug(&$p.input.cur())
)
.entered()
}
}};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/mod.rs | Rust | #![allow(clippy::let_unit_value)]
#![deny(non_snake_case)]
use std::ops::{Deref, DerefMut};
use rustc_hash::FxHashMap;
use swc_atoms::Atom;
use swc_common::{comments::Comments, input::StringInput, BytePos, Span};
use swc_ecma_ast::*;
pub use self::input::{Capturing, Tokens, TokensInput};
use self::{input::Buffer, util::ParseObject};
use crate::{
error::SyntaxError,
lexer::Lexer,
token::{Token, Word},
Context, EsVersion, Syntax, TsSyntax,
};
#[cfg(test)]
extern crate test;
#[cfg(test)]
use test::Bencher;
use crate::error::Error;
#[macro_use]
mod macros;
mod class_and_fn;
mod expr;
mod ident;
pub mod input;
mod jsx;
mod object;
mod pat;
mod stmt;
#[cfg(test)]
mod tests;
#[cfg(feature = "typescript")]
mod typescript;
mod util;
/// When error occurs, error is emitted and parser returns Err(()).
pub type PResult<T> = Result<T, Error>;
/// EcmaScript parser.
#[derive(Clone)]
pub struct Parser<I: Tokens> {
state: State,
input: Buffer<I>,
}
#[derive(Clone, Default)]
struct State {
labels: Vec<Atom>,
/// Start position of an assignment expression.
potential_arrow_start: Option<BytePos>,
found_module_item: bool,
/// Start position of an AST node and the span of its trailing comma.
trailing_commas: FxHashMap<BytePos, Span>,
}
impl<'a> Parser<Lexer<'a>> {
pub fn new(syntax: Syntax, input: StringInput<'a>, comments: Option<&'a dyn Comments>) -> Self {
Self::new_from(Lexer::new(syntax, Default::default(), input, comments))
}
}
impl<I: Tokens> Parser<I> {
pub fn new_from(mut input: I) -> Self {
#[cfg(feature = "typescript")]
let in_declare = matches!(
input.syntax(),
Syntax::Typescript(TsSyntax { dts: true, .. })
);
#[cfg(not(feature = "typescript"))]
let in_declare = false;
let ctx = Context {
in_declare,
..input.ctx()
};
input.set_ctx(ctx);
Parser {
state: Default::default(),
input: Buffer::new(input),
}
}
pub fn take_errors(&mut self) -> Vec<Error> {
self.input().take_errors()
}
pub fn take_script_module_errors(&mut self) -> Vec<Error> {
self.input().take_script_module_errors()
}
pub fn parse_script(&mut self) -> PResult<Script> {
trace_cur!(self, parse_script);
let ctx = Context {
module: false,
..self.ctx()
};
self.set_ctx(ctx);
let start = cur_pos!(self);
let shebang = self.parse_shebang()?;
self.parse_block_body(true, true, None).map(|body| Script {
span: span!(self, start),
body,
shebang,
})
}
pub fn parse_typescript_module(&mut self) -> PResult<Module> {
trace_cur!(self, parse_typescript_module);
debug_assert!(self.syntax().typescript());
//TODO: parse() -> PResult<Program>
let ctx = Context {
module: true,
strict: false,
..self.ctx()
};
// Module code is always in strict mode
self.set_ctx(ctx);
let start = cur_pos!(self);
let shebang = self.parse_shebang()?;
self.parse_block_body(true, true, None).map(|body| Module {
span: span!(self, start),
body,
shebang,
})
}
/// Returns [Module] if it's a module and returns [Script] if it's not a
/// module.
///
/// Note: This is not perfect yet. It means, some strict mode violations may
/// not be reported even if the method returns [Module].
pub fn parse_program(&mut self) -> PResult<Program> {
let start = cur_pos!(self);
let shebang = self.parse_shebang()?;
let ctx = Context {
can_be_module: true,
..self.ctx()
};
let body: Vec<ModuleItem> = self.with_ctx(ctx).parse_block_body(true, true, None)?;
let has_module_item = self.state.found_module_item
|| body
.iter()
.any(|item| matches!(item, ModuleItem::ModuleDecl(..)));
if has_module_item && !self.ctx().module {
let ctx = Context {
module: true,
can_be_module: true,
strict: true,
..self.ctx()
};
// Emit buffered strict mode / module code violations
self.input.set_ctx(ctx);
}
Ok(if has_module_item {
Program::Module(Module {
span: span!(self, start),
body,
shebang,
})
} else {
let body = body
.into_iter()
.map(|item| match item {
ModuleItem::ModuleDecl(_) => unreachable!("Module is handled above"),
ModuleItem::Stmt(stmt) => stmt,
})
.collect();
Program::Script(Script {
span: span!(self, start),
body,
shebang,
})
})
}
pub fn parse_module(&mut self) -> PResult<Module> {
let ctx = Context {
module: true,
can_be_module: true,
strict: true,
..self.ctx()
};
// Module code is always in strict mode
self.set_ctx(ctx);
let start = cur_pos!(self);
let shebang = self.parse_shebang()?;
self.parse_block_body(true, true, None).map(|body| Module {
span: span!(self, start),
body,
shebang,
})
}
fn parse_shebang(&mut self) -> PResult<Option<Atom>> {
match cur!(self, false) {
Ok(&Token::Shebang(..)) => match bump!(self) {
Token::Shebang(v) => Ok(Some(v)),
_ => unreachable!(),
},
_ => Ok(None),
}
}
fn ctx(&self) -> Context {
self.input.get_ctx()
}
#[cold]
fn emit_err(&mut self, span: Span, error: SyntaxError) {
if self.ctx().ignore_error || !self.syntax().early_errors() {
return;
}
self.emit_error(Error::new(span, error))
}
#[cold]
fn emit_error(&mut self, error: Error) {
if self.ctx().ignore_error || !self.syntax().early_errors() {
return;
}
if matches!(self.input.cur(), Some(Token::Error(..))) {
let err = self.input.bump();
match err {
Token::Error(err) => {
self.input_ref().add_error(err);
}
_ => unreachable!(),
}
}
self.input_ref().add_error(error);
}
#[cold]
fn emit_strict_mode_err(&self, span: Span, error: SyntaxError) {
if self.ctx().ignore_error {
return;
}
let error = Error::new(span, error);
self.input_ref().add_module_mode_error(error);
}
}
#[cfg(test)]
pub fn test_parser<F, Ret>(s: &'static str, syntax: Syntax, f: F) -> Ret
where
F: FnOnce(&mut Parser<Lexer>) -> Result<Ret, Error>,
{
crate::with_test_sess(s, |handler, input| {
let lexer = Lexer::new(syntax, EsVersion::Es2019, input, None);
let mut p = Parser::new_from(lexer);
let ret = f(&mut p);
let mut error = false;
for err in p.take_errors() {
error = true;
err.into_diagnostic(handler).emit();
}
let res = ret.map_err(|err| err.into_diagnostic(handler).emit())?;
if error {
return Err(());
}
Ok(res)
})
.unwrap_or_else(|output| panic!("test_parser(): failed to parse \n{}\n{}", s, output))
}
#[cfg(test)]
pub fn test_parser_comment<F, Ret>(c: &dyn Comments, s: &'static str, syntax: Syntax, f: F) -> Ret
where
F: FnOnce(&mut Parser<Lexer>) -> Result<Ret, Error>,
{
crate::with_test_sess(s, |handler, input| {
let lexer = Lexer::new(syntax, EsVersion::Es2019, input, Some(&c));
let mut p = Parser::new_from(lexer);
let ret = f(&mut p);
for err in p.take_errors() {
err.into_diagnostic(handler).emit();
}
ret.map_err(|err| err.into_diagnostic(handler).emit())
})
.unwrap_or_else(|output| panic!("test_parser(): failed to parse \n{}\n{}", s, output))
}
#[cfg(test)]
pub fn bench_parser<F>(b: &mut Bencher, s: &'static str, syntax: Syntax, mut f: F)
where
F: for<'a> FnMut(&'a mut Parser<Lexer<'a>>) -> PResult<()>,
{
b.bytes = s.len() as u64;
let _ = crate::with_test_sess(s, |handler, input| {
b.iter(|| {
let lexer = Lexer::new(syntax, Default::default(), input.clone(), None);
let _ =
f(&mut Parser::new_from(lexer)).map_err(|err| err.into_diagnostic(handler).emit());
});
Ok(())
});
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/object.rs | Rust | //! Parser for object literal.
use swc_common::{Spanned, DUMMY_SP};
use super::*;
use crate::parser::class_and_fn::is_not_this;
impl<I: Tokens> Parser<I> {
/// Parse a object literal or object pattern.
pub(super) fn parse_object<T>(&mut self) -> PResult<T>
where
Self: ParseObject<T>,
{
let ctx = Context {
will_expect_colon_for_cond: false,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
trace_cur!(p, parse_object);
let start = cur_pos!(p);
let mut trailing_comma = None;
assert_and_bump!(p, '{');
let mut props = Vec::new();
while !eat!(p, '}') {
props.push(p.parse_object_prop()?);
if !is!(p, '}') {
expect!(p, ',');
if is!(p, '}') {
trailing_comma = Some(p.input.prev_span());
}
}
}
p.make_object(span!(p, start), props, trailing_comma)
})
}
/// spec: 'PropertyName'
pub(super) fn parse_prop_name(&mut self) -> PResult<PropName> {
trace_cur!(self, parse_prop_name);
let ctx = self.ctx();
self.with_ctx(Context {
in_property_name: true,
..ctx
})
.parse_with(|p| {
let start = cur_pos!(p);
let v = match *cur!(p, true) {
Token::Str { .. } => match bump!(p) {
Token::Str { value, raw } => PropName::Str(Str {
span: span!(p, start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
Token::Num { .. } => match bump!(p) {
Token::Num { value, raw } => PropName::Num(Number {
span: span!(p, start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
Token::BigInt { .. } => match bump!(p) {
Token::BigInt { value, raw } => PropName::BigInt(BigInt {
span: span!(p, start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
Word(..) => match bump!(p) {
Word(w) => PropName::Ident(IdentName::new(w.into(), span!(p, start))),
_ => unreachable!(),
},
tok!('[') => {
bump!(p);
let inner_start = cur_pos!(p);
let mut expr = p.include_in_expr(true).parse_assignment_expr()?;
if p.syntax().typescript() && is!(p, ',') {
let mut exprs = vec![expr];
while eat!(p, ',') {
exprs.push(p.include_in_expr(true).parse_assignment_expr()?);
}
p.emit_err(span!(p, inner_start), SyntaxError::TS1171);
expr = Box::new(
SeqExpr {
span: span!(p, inner_start),
exprs,
}
.into(),
);
}
expect!(p, ']');
PropName::Computed(ComputedPropName {
span: span!(p, start),
expr,
})
}
_ => unexpected!(
p,
"identifier, string literal, numeric literal or [ for the computed key"
),
};
Ok(v)
})
}
}
impl<I: Tokens> ParseObject<Expr> for Parser<I> {
type Prop = PropOrSpread;
fn make_object(
&mut self,
span: Span,
props: Vec<Self::Prop>,
trailing_comma: Option<Span>,
) -> PResult<Expr> {
if let Some(trailing_comma) = trailing_comma {
self.state.trailing_commas.insert(span.lo, trailing_comma);
}
Ok(ObjectLit { span, props }.into())
}
/// spec: 'PropertyDefinition'
fn parse_object_prop(&mut self) -> PResult<Self::Prop> {
trace_cur!(self, parse_object_prop);
let start = cur_pos!(self);
// Parse as 'MethodDefinition'
if eat!(self, "...") {
// spread element
let dot3_token = span!(self, start);
let expr = self.include_in_expr(true).parse_assignment_expr()?;
return Ok(PropOrSpread::Spread(SpreadElement { dot3_token, expr }));
}
if eat!(self, '*') {
let name = self.parse_prop_name()?;
return self
.with_ctx(Context {
allow_direct_super: true,
in_class_field: false,
..self.ctx()
})
.parse_fn_args_body(
// no decorator in an object literal
Vec::new(),
start,
|p| p.parse_unique_formal_params(),
false,
true,
)
.map(|function| {
PropOrSpread::Prop(Box::new(Prop::Method(MethodProp {
key: name,
function,
})))
});
}
let has_modifiers = self.eat_any_ts_modifier()?;
let modifiers_span = self.input.prev_span();
let key = self.parse_prop_name()?;
if self.input.syntax().typescript()
&& !is_one_of!(self, '(', '[', ':', ',', '?', '=', '*', IdentName, Str, Num)
&& !(self.input.syntax().typescript() && is!(self, '<'))
&& !(is!(self, '}') && matches!(key, PropName::Ident(..)))
{
trace_cur!(self, parse_object_prop_error);
self.emit_err(self.input.cur_span(), SyntaxError::TS1005);
return Ok(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key,
value: Invalid {
span: span!(self, start),
}
.into(),
}))));
}
//
// {[computed()]: a,}
// { 'a': a, }
// { 0: 1, }
// { a: expr, }
if eat!(self, ':') {
let value = self.include_in_expr(true).parse_assignment_expr()?;
return Ok(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key,
value,
}))));
}
// Handle `a(){}` (and async(){} / get(){} / set(){})
if (self.input.syntax().typescript() && is!(self, '<')) || is!(self, '(') {
return self
.with_ctx(Context {
allow_direct_super: true,
in_class_field: false,
..self.ctx()
})
.parse_fn_args_body(
// no decorator in an object literal
Vec::new(),
start,
|p| p.parse_unique_formal_params(),
false,
false,
)
.map(|function| Box::new(Prop::Method(MethodProp { key, function })))
.map(PropOrSpread::Prop);
}
let ident = match key {
PropName::Ident(ident) => ident,
// TODO
_ => unexpected!(self, "identifier"),
};
if eat!(self, '?') {
self.emit_err(self.input.prev_span(), SyntaxError::TS1162);
}
// `ident` from parse_prop_name is parsed as 'IdentifierName'
// It means we should check for invalid expressions like { for, }
if is_one_of!(self, '=', ',', '}') {
let is_reserved_word = { self.ctx().is_reserved_word(&ident.sym) };
if is_reserved_word {
self.emit_err(ident.span, SyntaxError::ReservedWordInObjShorthandOrPat);
}
if eat!(self, '=') {
let value = self.include_in_expr(true).parse_assignment_expr()?;
let span = span!(self, start);
return Ok(PropOrSpread::Prop(Box::new(Prop::Assign(AssignProp {
span,
key: ident.into(),
value,
}))));
}
return Ok(PropOrSpread::Prop(Box::new(Prop::from(ident))));
}
// get a(){}
// set a(v){}
// async a(){}
match &*ident.sym {
"get" | "set" | "async" => {
trace_cur!(self, parse_object_prop__after_accessor);
if has_modifiers {
self.emit_err(modifiers_span, SyntaxError::TS1042);
}
let is_generator = ident.sym == "async" && eat!(self, '*');
let key = self.parse_prop_name()?;
let key_span = key.span();
self.with_ctx(Context {
allow_direct_super: true,
in_class_field: false,
..self.ctx()
})
.parse_with(|parser| {
match &*ident.sym {
"get" => parser
.parse_fn_args_body(
// no decorator in an object literal
Vec::new(),
start,
|p| {
let params = p.parse_formal_params()?;
if params.iter().filter(|p| is_not_this(p)).count() != 0 {
p.emit_err(key_span, SyntaxError::GetterParam);
}
Ok(params)
},
false,
false,
)
.map(|v| *v)
.map(
|Function {
body, return_type, ..
}| {
if parser.input.syntax().typescript()
&& parser.input.target() == EsVersion::Es3
{
parser.emit_err(key_span, SyntaxError::TS1056);
}
PropOrSpread::Prop(Box::new(Prop::Getter(GetterProp {
span: span!(parser, start),
key,
type_ann: return_type,
body,
})))
},
),
"set" => {
parser
.parse_fn_args_body(
// no decorator in an object literal
Vec::new(),
start,
|p| {
let params = p.parse_formal_params()?;
if params.iter().filter(|p| is_not_this(p)).count() != 1 {
p.emit_err(key_span, SyntaxError::SetterParam);
}
if !params.is_empty() {
if let Pat::Rest(..) = params[0].pat {
p.emit_err(
params[0].span(),
SyntaxError::RestPatInSetter,
);
}
}
if p.input.syntax().typescript()
&& p.input.target() == EsVersion::Es3
{
p.emit_err(key_span, SyntaxError::TS1056);
}
Ok(params)
},
false,
false,
)
.map(|v| *v)
.map(
|Function {
mut params, body, ..
}| {
let mut this = None;
if params.len() >= 2 {
this = Some(params.remove(0).pat);
}
let param = Box::new(
params
.into_iter()
.next()
.map(|v| v.pat)
.unwrap_or_else(|| {
parser.emit_err(
key_span,
SyntaxError::SetterParam,
);
Invalid { span: DUMMY_SP }.into()
}),
);
// debug_assert_eq!(params.len(), 1);
PropOrSpread::Prop(Box::new(Prop::Setter(SetterProp {
span: span!(parser, start),
key,
body,
param,
this_param: this,
})))
},
)
}
"async" => parser
.parse_fn_args_body(
// no decorator in an object literal
Vec::new(),
start,
|p| p.parse_unique_formal_params(),
true,
is_generator,
)
.map(|function| {
PropOrSpread::Prop(Box::new(Prop::Method(MethodProp {
key,
function,
})))
}),
_ => unreachable!(),
}
})
}
_ => {
if self.input.syntax().typescript() {
unexpected!(
self,
"... , *, (, [, :, , ?, =, an identifier, public, protected, private, \
readonly, <."
)
} else {
unexpected!(self, "... , *, (, [, :, , ?, = or an identifier")
}
}
}
}
}
impl<I: Tokens> ParseObject<Pat> for Parser<I> {
type Prop = ObjectPatProp;
fn make_object(
&mut self,
span: Span,
props: Vec<Self::Prop>,
trailing_comma: Option<Span>,
) -> PResult<Pat> {
let len = props.len();
for (i, p) in props.iter().enumerate() {
if i == len - 1 {
if let ObjectPatProp::Rest(ref rest) = p {
match *rest.arg {
Pat::Ident(..) => {
if let Some(trailing_comma) = trailing_comma {
self.emit_err(trailing_comma, SyntaxError::CommaAfterRestElement);
}
}
_ => syntax_error!(self, p.span(), SyntaxError::DotsWithoutIdentifier),
}
}
continue;
}
if let ObjectPatProp::Rest(..) = p {
self.emit_err(p.span(), SyntaxError::NonLastRestParam)
}
}
let optional = (self.input.syntax().dts() || self.ctx().in_declare) && eat!(self, '?');
Ok(ObjectPat {
span,
props,
optional,
type_ann: None,
}
.into())
}
/// Production 'BindingProperty'
fn parse_object_prop(&mut self) -> PResult<Self::Prop> {
let start = cur_pos!(self);
if eat!(self, "...") {
// spread element
let dot3_token = span!(self, start);
let arg = Box::new(self.parse_binding_pat_or_ident(false)?);
return Ok(ObjectPatProp::Rest(RestPat {
span: span!(self, start),
dot3_token,
arg,
type_ann: None,
}));
}
let key = self.parse_prop_name()?;
if eat!(self, ':') {
let value = Box::new(self.parse_binding_element()?);
return Ok(ObjectPatProp::KeyValue(KeyValuePatProp { key, value }));
}
let key = match key {
PropName::Ident(ident) => ident,
_ => unexpected!(self, "an identifier"),
};
let value = if eat!(self, '=') {
self.include_in_expr(true)
.parse_assignment_expr()
.map(Some)?
} else {
if self.ctx().is_reserved_word(&key.sym) {
self.emit_err(key.span, SyntaxError::ReservedWordInObjShorthandOrPat);
}
None
};
Ok(ObjectPatProp::Assign(AssignPatProp {
span: span!(self, start),
key: key.into(),
value,
}))
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/pat.rs | Rust | //! 13.3.3 Destructuring Binding Patterns
use swc_common::Spanned;
use super::{util::ExprExt, *};
use crate::{
parser::{class_and_fn::is_not_this, expr::AssignTargetOrSpread},
token::{IdentLike, Keyword},
};
impl<I: Tokens> Parser<I> {
pub fn parse_pat(&mut self) -> PResult<Pat> {
self.parse_binding_pat_or_ident(false)
}
pub(super) fn parse_opt_binding_ident(
&mut self,
disallow_let: bool,
) -> PResult<Option<BindingIdent>> {
trace_cur!(self, parse_opt_binding_ident);
if is!(self, BindingIdent) || (self.input.syntax().typescript() && is!(self, "this")) {
self.parse_binding_ident(disallow_let).map(Some)
} else {
Ok(None)
}
}
/// babel: `parseBindingIdentifier`
///
/// spec: `BindingIdentifier`
pub(super) fn parse_binding_ident(&mut self, disallow_let: bool) -> PResult<BindingIdent> {
trace_cur!(self, parse_binding_ident);
if disallow_let {
if let Some(Token::Word(Word::Keyword(Keyword::Let))) = self.input.cur() {
unexpected!(self, "let is reserved in const, let, class declaration")
}
}
// "yield" and "await" is **lexically** accepted.
let ident = self.parse_ident(true, true)?;
if ident.is_reserved_in_strict_bind() {
self.emit_strict_mode_err(ident.span, SyntaxError::EvalAndArgumentsInStrict);
}
if (self.ctx().in_async || self.ctx().in_static_block) && ident.sym == "await" {
self.emit_err(ident.span, SyntaxError::ExpectedIdent);
}
if self.ctx().in_generator && ident.sym == "yield" {
self.emit_err(ident.span, SyntaxError::ExpectedIdent);
}
Ok(ident.into())
}
pub(super) fn parse_binding_pat_or_ident(&mut self, disallow_let: bool) -> PResult<Pat> {
trace_cur!(self, parse_binding_pat_or_ident);
match *cur!(self, true) {
tok!("yield") | Word(..) => self.parse_binding_ident(disallow_let).map(Pat::from),
tok!('[') => self.parse_array_binding_pat(),
tok!('{') => self.parse_object(),
// tok!('(') => {
// bump!(self);
// let pat = self.parse_binding_pat_or_ident()?;
// expect!(self, ')');
// Ok(pat)
// }
_ => unexpected!(self, "yield, an identifier, [ or {"),
}
}
/// babel: `parseBindingAtom`
pub(super) fn parse_binding_element(&mut self) -> PResult<Pat> {
trace_cur!(self, parse_binding_element);
let start = cur_pos!(self);
let left = self.parse_binding_pat_or_ident(false)?;
if eat!(self, '=') {
let right = self.include_in_expr(true).parse_assignment_expr()?;
if self.ctx().in_declare {
self.emit_err(span!(self, start), SyntaxError::TS2371);
}
return Ok(AssignPat {
span: span!(self, start),
left: Box::new(left),
right,
}
.into());
}
Ok(left)
}
fn parse_array_binding_pat(&mut self) -> PResult<Pat> {
let start = cur_pos!(self);
assert_and_bump!(self, '[');
let mut elems = Vec::new();
let mut rest_span = Span::default();
while !eof!(self) && !is!(self, ']') {
if eat!(self, ',') {
elems.push(None);
continue;
}
if !rest_span.is_dummy() {
self.emit_err(rest_span, SyntaxError::NonLastRestParam);
}
let start = cur_pos!(self);
let mut is_rest = false;
if eat!(self, "...") {
is_rest = true;
let dot3_token = span!(self, start);
let pat = self.parse_binding_pat_or_ident(false)?;
rest_span = span!(self, start);
let pat = RestPat {
span: rest_span,
dot3_token,
arg: Box::new(pat),
type_ann: None,
}
.into();
elems.push(Some(pat));
} else {
elems.push(self.parse_binding_element().map(Some)?);
}
if !is!(self, ']') {
expect!(self, ',');
if is_rest && is!(self, ']') {
self.emit_err(self.input.prev_span(), SyntaxError::CommaAfterRestElement);
}
}
}
expect!(self, ']');
let optional = (self.input.syntax().dts() || self.ctx().in_declare) && eat!(self, '?');
Ok(ArrayPat {
span: span!(self, start),
elems,
optional,
type_ann: None,
}
.into())
}
pub(super) fn eat_any_ts_modifier(&mut self) -> PResult<bool> {
let has_modifier = self.syntax().typescript()
&& matches!(
*cur!(self, false)?,
Word(Word::Ident(IdentLike::Known(
known_ident!("public")
| known_ident!("protected")
| known_ident!("private")
| known_ident!("readonly")
)))
)
&& (peeked_is!(self, IdentName) || peeked_is!(self, '{') || peeked_is!(self, '['));
if has_modifier {
let _ = self.parse_ts_modifier(&["public", "protected", "private", "readonly"], false);
}
Ok(has_modifier)
}
/// spec: 'FormalParameter'
///
/// babel: `parseAssignableListItem`
pub(super) fn parse_formal_param_pat(&mut self) -> PResult<Pat> {
let start = cur_pos!(self);
let has_modifier = self.eat_any_ts_modifier()?;
let pat_start = cur_pos!(self);
let mut pat = self.parse_binding_element()?;
let mut opt = false;
if self.input.syntax().typescript() {
if eat!(self, '?') {
match pat {
Pat::Ident(BindingIdent {
id:
Ident {
ref mut optional, ..
},
..
})
| Pat::Array(ArrayPat {
ref mut optional, ..
})
| Pat::Object(ObjectPat {
ref mut optional, ..
}) => {
*optional = true;
opt = true;
}
_ if self.input.syntax().dts() || self.ctx().in_declare => {}
_ => {
syntax_error!(
self,
self.input.prev_span(),
SyntaxError::TsBindingPatCannotBeOptional
);
}
}
}
match pat {
Pat::Array(ArrayPat {
ref mut type_ann,
ref mut span,
..
})
| Pat::Object(ObjectPat {
ref mut type_ann,
ref mut span,
..
})
| Pat::Rest(RestPat {
ref mut type_ann,
ref mut span,
..
}) => {
let new_type_ann = self.try_parse_ts_type_ann()?;
if new_type_ann.is_some() {
*span = Span::new(pat_start, self.input.prev_span().hi);
}
*type_ann = new_type_ann;
}
Pat::Ident(BindingIdent {
ref mut type_ann, ..
}) => {
let new_type_ann = self.try_parse_ts_type_ann()?;
*type_ann = new_type_ann;
}
Pat::Assign(AssignPat { ref mut span, .. }) => {
if (self.try_parse_ts_type_ann()?).is_some() {
*span = Span::new(pat_start, self.input.prev_span().hi);
self.emit_err(*span, SyntaxError::TSTypeAnnotationAfterAssign);
}
}
Pat::Invalid(..) => {}
_ => unreachable!("invalid syntax: Pat: {:?}", pat),
}
}
let pat = if eat!(self, '=') {
// `=` cannot follow optional parameter.
if opt {
self.emit_err(pat.span(), SyntaxError::TS1015);
}
let right = self.parse_assignment_expr()?;
if self.ctx().in_declare {
self.emit_err(span!(self, start), SyntaxError::TS2371);
}
AssignPat {
span: span!(self, start),
left: Box::new(pat),
right,
}
.into()
} else {
pat
};
if has_modifier {
self.emit_err(span!(self, start), SyntaxError::TS2369);
return Ok(pat);
}
Ok(pat)
}
pub(super) fn parse_constructor_params(&mut self) -> PResult<Vec<ParamOrTsParamProp>> {
let mut params = Vec::new();
let mut rest_span = Span::default();
while !eof!(self) && !is!(self, ')') {
if !rest_span.is_dummy() {
self.emit_err(rest_span, SyntaxError::TS1014);
}
let param_start = cur_pos!(self);
let decorators = self.parse_decorators(false)?;
let pat_start = cur_pos!(self);
let mut is_rest = false;
if eat!(self, "...") {
is_rest = true;
let dot3_token = span!(self, pat_start);
let pat = self.parse_binding_pat_or_ident(false)?;
let type_ann = if self.input.syntax().typescript() && is!(self, ':') {
let cur_pos = cur_pos!(self);
Some(self.parse_ts_type_ann(/* eat_colon */ true, cur_pos)?)
} else {
None
};
rest_span = span!(self, pat_start);
let pat = RestPat {
span: rest_span,
dot3_token,
arg: Box::new(pat),
type_ann,
}
.into();
params.push(ParamOrTsParamProp::Param(Param {
span: span!(self, param_start),
decorators,
pat,
}));
} else {
params.push(self.parse_constructor_param(param_start, decorators)?);
}
if !is!(self, ')') {
expect!(self, ',');
if is!(self, ')') && is_rest {
self.emit_err(self.input.prev_span(), SyntaxError::CommaAfterRestElement);
}
}
}
Ok(params)
}
fn parse_constructor_param(
&mut self,
param_start: BytePos,
decorators: Vec<Decorator>,
) -> PResult<ParamOrTsParamProp> {
let (accessibility, is_override, readonly) = if self.input.syntax().typescript() {
let accessibility = self.parse_access_modifier()?;
(
accessibility,
self.parse_ts_modifier(&["override"], false)?.is_some(),
self.parse_ts_modifier(&["readonly"], false)?.is_some(),
)
} else {
(None, false, false)
};
if accessibility.is_none() && !is_override && !readonly {
let pat = self.parse_formal_param_pat()?;
Ok(ParamOrTsParamProp::Param(Param {
span: span!(self, param_start),
decorators,
pat,
}))
} else {
let param = match self.parse_formal_param_pat()? {
Pat::Ident(i) => TsParamPropParam::Ident(i),
Pat::Assign(a) => TsParamPropParam::Assign(a),
node => syntax_error!(self, node.span(), SyntaxError::TsInvalidParamPropPat),
};
Ok(ParamOrTsParamProp::TsParamProp(TsParamProp {
span: span!(self, param_start),
accessibility,
is_override,
readonly,
decorators,
param,
}))
}
}
#[allow(dead_code)]
pub(super) fn parse_setter_param(&mut self, key_span: Span) -> PResult<Param> {
let params = self.parse_formal_params()?;
let cnt = params.iter().filter(|p| is_not_this(p)).count();
if cnt != 1 {
self.emit_err(key_span, SyntaxError::SetterParam);
}
if !params.is_empty() {
if let Pat::Rest(..) = params[0].pat {
self.emit_err(params[0].pat.span(), SyntaxError::RestPatInSetter);
}
}
if params.is_empty() {
syntax_error!(self, SyntaxError::SetterParamRequired);
}
Ok(params.into_iter().next().unwrap())
}
pub(super) fn parse_formal_params(&mut self) -> PResult<Vec<Param>> {
let mut params = Vec::new();
let mut rest_span = Span::default();
while !eof!(self) && !is!(self, ')') {
if !rest_span.is_dummy() {
self.emit_err(rest_span, SyntaxError::TS1014);
}
let param_start = cur_pos!(self);
let decorators = self.parse_decorators(false)?;
let pat_start = cur_pos!(self);
let pat = if eat!(self, "...") {
let dot3_token = span!(self, pat_start);
let mut pat = self.parse_binding_pat_or_ident(false)?;
if eat!(self, '=') {
let right = self.parse_assignment_expr()?;
self.emit_err(pat.span(), SyntaxError::TS1048);
pat = AssignPat {
span: span!(self, pat_start),
left: Box::new(pat),
right,
}
.into();
}
let type_ann = if self.input.syntax().typescript() && is!(self, ':') {
let cur_pos = cur_pos!(self);
let ty = self.parse_ts_type_ann(/* eat_colon */ true, cur_pos)?;
Some(ty)
} else {
None
};
rest_span = span!(self, pat_start);
let pat = RestPat {
span: rest_span,
dot3_token,
arg: Box::new(pat),
type_ann,
}
.into();
if self.syntax().typescript() && eat!(self, '?') {
self.emit_err(self.input.prev_span(), SyntaxError::TS1047);
//
}
pat
} else {
self.parse_formal_param_pat()?
};
let is_rest = matches!(pat, Pat::Rest(_));
params.push(Param {
span: span!(self, param_start),
decorators,
pat,
});
if !is!(self, ')') {
expect!(self, ',');
if is_rest && is!(self, ')') {
self.emit_err(self.input.prev_span(), SyntaxError::CommaAfterRestElement);
}
}
}
Ok(params)
}
pub(super) fn parse_unique_formal_params(&mut self) -> PResult<Vec<Param>> {
// FIXME: This is wrong
self.parse_formal_params()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PatType {
BindingPat,
BindingElement,
/// AssignmentPattern
AssignPat,
AssignElement,
}
impl PatType {
pub fn element(self) -> Self {
match self {
PatType::BindingPat | PatType::BindingElement => PatType::BindingElement,
PatType::AssignPat | PatType::AssignElement => PatType::AssignElement,
}
}
}
impl<I: Tokens> Parser<I> {
/// This does not return 'rest' pattern because non-last parameter cannot be
/// rest.
pub(super) fn reparse_expr_as_pat(&mut self, pat_ty: PatType, expr: Box<Expr>) -> PResult<Pat> {
if let Expr::Invalid(i) = *expr {
return Ok(i.into());
}
if pat_ty == PatType::AssignPat {
match *expr {
Expr::Object(..) | Expr::Array(..) => {
// It is a Syntax Error if LeftHandSideExpression is either
// an ObjectLiteral or an ArrayLiteral
// and LeftHandSideExpression cannot
// be reparsed as an AssignmentPattern.
}
_ => {
self.check_assign_target(&expr, true);
}
}
}
self.reparse_expr_as_pat_inner(pat_ty, expr)
}
fn reparse_expr_as_pat_inner(&mut self, pat_ty: PatType, expr: Box<Expr>) -> PResult<Pat> {
// In dts, we do not reparse.
debug_assert!(!self.input.syntax().dts());
let span = expr.span();
if pat_ty == PatType::AssignPat {
match *expr {
Expr::Object(..) | Expr::Array(..) => {
// It is a Syntax Error if LeftHandSideExpression is either
// an ObjectLiteral or an ArrayLiteral
// and LeftHandSideExpression cannot
// be reparsed as an AssignmentPattern.
}
_ => match *expr {
// It is a Syntax Error if the LeftHandSideExpression is
// CoverParenthesizedExpressionAndArrowParameterList:(Expression) and
// Expression derives a phrase that would produce a Syntax Error according
// to these rules if that phrase were substituted for
// LeftHandSideExpression. This rule is recursively applied.
Expr::Paren(..) => {
return Ok(expr.into());
}
Expr::Ident(i) => return Ok(i.into()),
_ => {
return Ok(expr.into());
}
},
}
}
// AssignmentElement:
// DestructuringAssignmentTarget Initializer[+In]?
//
// DestructuringAssignmentTarget:
// LeftHandSideExpression
if pat_ty == PatType::AssignElement {
match *expr {
Expr::Array(..) | Expr::Object(..) => {}
Expr::Member(..)
| Expr::SuperProp(..)
| Expr::Call(..)
| Expr::New(..)
| Expr::Lit(..)
| Expr::Ident(..)
| Expr::Fn(..)
| Expr::Class(..)
| Expr::Paren(..)
| Expr::Tpl(..)
| Expr::TsAs(..) => {
if !expr.is_valid_simple_assignment_target(self.ctx().strict) {
self.emit_err(span, SyntaxError::NotSimpleAssign)
}
match *expr {
Expr::Ident(i) => return Ok(i.into()),
_ => {
return Ok(expr.into());
}
}
}
// It's special because of optional initializer
Expr::Assign(..) => {}
_ => self.emit_err(span, SyntaxError::InvalidPat),
}
}
match *expr {
Expr::Paren(..) => {
self.emit_err(span, SyntaxError::InvalidPat);
Ok(Invalid { span }.into())
}
Expr::Assign(
assign_expr @ AssignExpr {
op: AssignOp::Assign,
..
},
) => {
let AssignExpr {
span, left, right, ..
} = assign_expr;
Ok(AssignPat {
span,
left: match left {
AssignTarget::Simple(left) => {
Box::new(self.reparse_expr_as_pat(pat_ty, left.into())?)
}
AssignTarget::Pat(pat) => pat.into(),
},
right,
}
.into())
}
Expr::Object(ObjectLit {
span: object_span,
props,
}) => {
// {}
let len = props.len();
Ok(ObjectPat {
span: object_span,
props: props
.into_iter()
.enumerate()
.map(|(idx, prop)| {
let span = prop.span();
match prop {
PropOrSpread::Prop(prop) => match *prop {
Prop::Shorthand(id) => {
Ok(ObjectPatProp::Assign(AssignPatProp {
span: id.span(),
key: id.into(),
value: None,
}))
}
Prop::KeyValue(kv_prop) => {
Ok(ObjectPatProp::KeyValue(KeyValuePatProp {
key: kv_prop.key,
value: Box::new(self.reparse_expr_as_pat(
pat_ty.element(),
kv_prop.value,
)?),
}))
}
Prop::Assign(assign_prop) => {
Ok(ObjectPatProp::Assign(AssignPatProp {
span,
key: assign_prop.key.into(),
value: Some(assign_prop.value),
}))
}
_ => syntax_error!(self, prop.span(), SyntaxError::InvalidPat),
},
PropOrSpread::Spread(SpreadElement { dot3_token, expr }) => {
if idx != len - 1 {
self.emit_err(span, SyntaxError::NonLastRestParam)
} else if let Some(trailing_comma) =
self.state.trailing_commas.get(&object_span.lo)
{
self.emit_err(
*trailing_comma,
SyntaxError::CommaAfterRestElement,
);
};
let element_pat_ty = pat_ty.element();
let pat = if let PatType::BindingElement = element_pat_ty {
if let Expr::Ident(i) = *expr {
i.into()
} else {
self.emit_err(span, SyntaxError::DotsWithoutIdentifier);
Pat::Invalid(Invalid { span })
}
} else {
self.reparse_expr_as_pat(element_pat_ty, expr)?
};
if let Pat::Assign(_) = pat {
self.emit_err(span, SyntaxError::TS1048)
};
Ok(ObjectPatProp::Rest(RestPat {
span,
dot3_token,
arg: Box::new(pat),
type_ann: None,
}))
}
}
})
.collect::<PResult<_>>()?,
optional: false,
type_ann: None,
}
.into())
}
Expr::Ident(ident) => Ok(ident.into()),
Expr::Array(ArrayLit {
elems: mut exprs, ..
}) => {
if exprs.is_empty() {
return Ok(ArrayPat {
span,
elems: Vec::new(),
optional: false,
type_ann: None,
}
.into());
}
// Trailing comma may exist. We should remove those commas.
let count_of_trailing_comma =
exprs.iter().rev().take_while(|e| e.is_none()).count();
let len = exprs.len();
let mut params = Vec::with_capacity(exprs.len() - count_of_trailing_comma);
// Comma or other pattern cannot follow a rest pattern.
let idx_of_rest_not_allowed = if count_of_trailing_comma == 0 {
len - 1
} else {
// last element is comma, so rest is not allowed for every pattern element.
len - count_of_trailing_comma
};
for expr in exprs.drain(..idx_of_rest_not_allowed) {
match expr {
Some(
expr @ ExprOrSpread {
spread: Some(..), ..
},
) => self.emit_err(expr.span(), SyntaxError::NonLastRestParam),
Some(ExprOrSpread { expr, .. }) => {
params.push(self.reparse_expr_as_pat(pat_ty.element(), expr).map(Some)?)
}
None => params.push(None),
}
}
if count_of_trailing_comma == 0 {
let expr = exprs.into_iter().next().unwrap();
let outer_expr_span = expr.span();
let last = match expr {
// Rest
Some(ExprOrSpread {
spread: Some(dot3_token),
expr,
}) => {
// TODO: is BindingPat correct?
if let Expr::Assign(_) = *expr {
self.emit_err(outer_expr_span, SyntaxError::TS1048);
};
if let Some(trailing_comma) = self.state.trailing_commas.get(&span.lo) {
self.emit_err(*trailing_comma, SyntaxError::CommaAfterRestElement);
}
let expr_span = expr.span();
self.reparse_expr_as_pat(pat_ty.element(), expr)
.map(|pat| {
RestPat {
span: expr_span,
dot3_token,
arg: Box::new(pat),
type_ann: None,
}
.into()
})
.map(Some)?
}
Some(ExprOrSpread { expr, .. }) => {
// TODO: is BindingPat correct?
self.reparse_expr_as_pat(pat_ty.element(), expr).map(Some)?
}
// TODO: syntax error if last element is ellison and ...rest exists.
None => None,
};
params.push(last);
}
Ok(ArrayPat {
span,
elems: params,
optional: false,
type_ann: None,
}
.into())
}
// Invalid patterns.
// Note that assignment expression with '=' is valid, and handled above.
Expr::Lit(..) | Expr::Assign(..) => {
self.emit_err(span, SyntaxError::InvalidPat);
Ok(Invalid { span }.into())
}
Expr::Yield(..) if self.ctx().in_generator => {
self.emit_err(span, SyntaxError::InvalidPat);
Ok(Invalid { span }.into())
}
_ => {
self.emit_err(span, SyntaxError::InvalidPat);
Ok(Invalid { span }.into())
}
}
}
pub(super) fn parse_paren_items_as_params(
&mut self,
mut exprs: Vec<AssignTargetOrSpread>,
trailing_comma: Option<Span>,
) -> PResult<Vec<Pat>> {
let pat_ty = PatType::BindingPat;
let len = exprs.len();
if len == 0 {
return Ok(Vec::new());
}
let mut params = Vec::with_capacity(len);
for expr in exprs.drain(..len - 1) {
match expr {
AssignTargetOrSpread::ExprOrSpread(ExprOrSpread {
spread: Some(..), ..
})
| AssignTargetOrSpread::Pat(Pat::Rest(..)) => {
self.emit_err(expr.span(), SyntaxError::TS1014)
}
AssignTargetOrSpread::ExprOrSpread(ExprOrSpread {
spread: None, expr, ..
}) => params.push(self.reparse_expr_as_pat(pat_ty, expr)?),
AssignTargetOrSpread::Pat(pat) => params.push(pat),
}
}
debug_assert_eq!(exprs.len(), 1);
let expr = exprs.into_iter().next().unwrap();
let outer_expr_span = expr.span();
let last = match expr {
// Rest
AssignTargetOrSpread::ExprOrSpread(ExprOrSpread {
spread: Some(dot3_token),
expr,
}) => {
if let Expr::Assign(_) = *expr {
self.emit_err(outer_expr_span, SyntaxError::TS1048)
};
if let Some(trailing_comma) = trailing_comma {
self.emit_err(trailing_comma, SyntaxError::CommaAfterRestElement);
}
let expr_span = expr.span();
self.reparse_expr_as_pat(pat_ty, expr).map(|pat| {
RestPat {
span: expr_span,
dot3_token,
arg: Box::new(pat),
type_ann: None,
}
.into()
})?
}
AssignTargetOrSpread::ExprOrSpread(ExprOrSpread { expr, .. }) => {
self.reparse_expr_as_pat(pat_ty, expr)?
}
AssignTargetOrSpread::Pat(pat) => {
if let Some(trailing_comma) = trailing_comma {
if let Pat::Rest(..) = pat {
self.emit_err(trailing_comma, SyntaxError::CommaAfterRestElement);
}
}
pat
}
};
params.push(last);
if self.ctx().strict {
for param in params.iter() {
self.pat_is_valid_argument_in_strict(param)
}
}
Ok(params)
}
/// argument of arrow is pattern, although idents in pattern is already
/// checked if is a keyword, it should also be checked if is arguments or
/// eval
fn pat_is_valid_argument_in_strict(&self, pat: &Pat) {
match pat {
Pat::Ident(i) => {
if i.is_reserved_in_strict_bind() {
self.emit_strict_mode_err(i.span, SyntaxError::EvalAndArgumentsInStrict)
}
}
Pat::Array(arr) => {
for pat in arr.elems.iter().flatten() {
self.pat_is_valid_argument_in_strict(pat)
}
}
Pat::Rest(r) => self.pat_is_valid_argument_in_strict(&r.arg),
Pat::Object(obj) => {
for prop in obj.props.iter() {
match prop {
ObjectPatProp::KeyValue(KeyValuePatProp { value, .. })
| ObjectPatProp::Rest(RestPat { arg: value, .. }) => {
self.pat_is_valid_argument_in_strict(value)
}
ObjectPatProp::Assign(AssignPatProp { key, .. }) => {
if key.is_reserved_in_strict_bind() {
self.emit_strict_mode_err(
key.span,
SyntaxError::EvalAndArgumentsInStrict,
)
}
}
}
}
}
Pat::Assign(a) => self.pat_is_valid_argument_in_strict(&a.left),
Pat::Invalid(_) | Pat::Expr(_) => (),
}
}
}
#[cfg(test)]
mod tests {
use swc_common::DUMMY_SP as span;
use swc_ecma_visit::assert_eq_ignore_span;
use super::*;
fn array_pat(s: &'static str) -> Pat {
test_parser(s, Syntax::default(), |p| p.parse_array_binding_pat())
}
fn object_pat(s: &'static str) -> Pat {
test_parser(s, Syntax::default(), |p| {
p.parse_binding_pat_or_ident(false)
})
}
fn ident(s: &str) -> Ident {
Ident::new_no_ctxt(s.into(), span)
}
fn ident_name(s: &str) -> IdentName {
IdentName::new(s.into(), span)
}
fn rest() -> Option<Pat> {
Some(
RestPat {
span,
dot3_token: span,
type_ann: None,
arg: ident("tail").into(),
}
.into(),
)
}
#[test]
fn array_pat_simple() {
assert_eq_ignore_span!(
array_pat("[a, [b], [c]]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![
Some(Pat::Ident(ident("a").into())),
Some(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("b").into()))],
type_ann: None
})),
Some(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("c").into()))],
type_ann: None
}))
],
type_ann: None
})
);
}
#[test]
fn array_pat_empty_start() {
assert_eq_ignore_span!(
array_pat("[, a, [b], [c]]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![
None,
Some(Pat::Ident(ident("a").into())),
Some(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("b").into()))],
type_ann: None
})),
Some(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("c").into()))],
type_ann: None
}))
],
type_ann: None
})
);
}
#[test]
fn array_pat_empty() {
assert_eq_ignore_span!(
array_pat("[a, , [b], [c]]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![
Some(Pat::Ident(ident("a").into())),
None,
Some(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("b").into()))],
type_ann: None
})),
Some(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("c").into()))],
type_ann: None
}))
],
type_ann: None
})
);
}
#[test]
fn array_pat_empty_end() {
assert_eq_ignore_span!(
array_pat("[a, ,]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![Some(Pat::Ident(ident("a").into())), None,],
type_ann: None
})
);
}
#[test]
fn array_binding_pattern_tail() {
assert_eq_ignore_span!(
array_pat("[...tail]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![rest()],
type_ann: None
})
);
}
#[test]
fn array_binding_pattern_assign() {
assert_eq_ignore_span!(
array_pat("[,a=1,]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![
None,
Some(Pat::Assign(AssignPat {
span,
left: Box::new(Pat::Ident(ident("a").into())),
right: Box::new(Expr::Lit(Lit::Num(Number {
span,
value: 1.0,
raw: Some("1".into())
})))
}))
],
type_ann: None
})
);
}
#[test]
fn array_binding_pattern_tail_with_elems() {
assert_eq_ignore_span!(
array_pat("[,,,...tail]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![None, None, None, rest()],
type_ann: None
})
);
}
#[test]
fn array_binding_pattern_tail_inside_tail() {
assert_eq_ignore_span!(
array_pat("[,,,...[...tail]]"),
Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![
None,
None,
None,
Some(Pat::Rest(RestPat {
span,
dot3_token: span,
type_ann: None,
arg: Box::new(Pat::Array(ArrayPat {
span,
optional: false,
elems: vec![rest()],
type_ann: None
}))
}))
],
type_ann: None
})
);
}
#[test]
fn object_binding_pattern_tail() {
assert_eq_ignore_span!(
object_pat("{...obj}"),
Pat::Object(ObjectPat {
span,
type_ann: None,
optional: false,
props: vec![ObjectPatProp::Rest(RestPat {
span,
dot3_token: span,
type_ann: None,
arg: Box::new(Pat::Ident(ident("obj").into()))
})]
})
);
}
#[test]
fn object_binding_pattern_with_prop() {
assert_eq_ignore_span!(
object_pat("{prop = 10 }"),
Pat::Object(ObjectPat {
span,
type_ann: None,
optional: false,
props: vec![ObjectPatProp::Assign(AssignPatProp {
span,
key: ident("prop").into(),
value: Some(Box::new(Expr::Lit(Lit::Num(Number {
span,
value: 10.0,
raw: Some("10".into())
}))))
})]
})
);
}
#[test]
fn object_binding_pattern_with_prop_and_label() {
fn prop(key: PropName, assign_name: &str, expr: Expr) -> PropOrSpread {
PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key,
value: AssignExpr {
span,
op: AssignOp::Assign,
left: ident(assign_name).into(),
right: Box::new(expr),
}
.into(),
})))
}
assert_eq_ignore_span!(
object_pat(
"{obj = {$: num = 10, '': sym = '', \" \": quote = \" \", _: under = [...tail],}}"
),
Pat::Object(ObjectPat {
span,
type_ann: None,
optional: false,
props: vec![ObjectPatProp::Assign(AssignPatProp {
span,
key: ident("obj").into(),
value: Some(Box::new(Expr::Object(ObjectLit {
span,
props: vec![
prop(
PropName::Ident(ident_name("$")),
"num",
Expr::Lit(Lit::Num(Number {
span,
value: 10.0,
raw: Some("10".into())
}))
),
prop(
PropName::Str(Str {
span,
value: "".into(),
raw: Some("''".into()),
}),
"sym",
Expr::Lit(Lit::Str(Str {
span,
value: "".into(),
raw: Some("''".into()),
}))
),
prop(
PropName::Str(Str {
span,
value: " ".into(),
raw: Some("\" \"".into()),
}),
"quote",
Expr::Lit(Lit::Str(Str {
span,
value: " ".into(),
raw: Some("\" \"".into()),
}))
),
prop(
PropName::Ident(ident_name("_")),
"under",
Expr::Array(ArrayLit {
span,
elems: vec![Some(ExprOrSpread {
spread: Some(span),
expr: Box::new(Expr::Ident(ident("tail")))
})]
})
),
]
})))
})]
})
);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/stmt.rs | Rust | use swc_common::Spanned;
use typed_arena::Arena;
use super::{pat::PatType, *};
use crate::error::SyntaxError;
mod module_item;
impl<'a, I: Tokens> Parser<I> {
pub fn parse_module_item(&mut self) -> PResult<ModuleItem> {
self.parse_stmt_like(true, true)
}
pub(super) fn parse_block_body<Type>(
&mut self,
mut allow_directives: bool,
top_level: bool,
end: Option<&'static Token>,
) -> PResult<Vec<Type>>
where
Self: StmtLikeParser<'a, Type>,
Type: IsDirective + From<Stmt>,
{
trace_cur!(self, parse_block_body);
let old_ctx = self.ctx();
let stmts = Arena::new();
while {
if self.input.cur().is_none() && end.is_some() {
let eof_text = self.input.dump_cur();
self.emit_err(
self.input.cur_span(),
SyntaxError::Expected(end.unwrap(), eof_text),
);
false
} else {
let c = cur!(self, false).ok();
c != end
}
} {
let stmt = self.parse_stmt_like(true, top_level)?;
if allow_directives {
allow_directives = false;
if stmt.is_use_strict() {
let ctx = Context {
strict: true,
..old_ctx
};
self.set_ctx(ctx);
if self.input.knows_cur() && !is!(self, ';') {
unreachable!(
"'use strict'; directive requires parser.input.cur to be empty or \
'}}', but current token was: {:?}",
self.input.cur()
)
}
}
}
stmts.alloc(stmt);
}
if self.input.cur().is_some() && end.is_some() {
bump!(self);
}
self.set_ctx(old_ctx);
Ok(stmts.into_vec())
}
/// Parse a statement but not a declaration.
pub fn parse_stmt(&mut self, top_level: bool) -> PResult<Stmt> {
trace_cur!(self, parse_stmt);
self.parse_stmt_like(false, top_level)
}
/// Parse a statement and maybe a declaration.
pub fn parse_stmt_list_item(&mut self, top_level: bool) -> PResult<Stmt> {
trace_cur!(self, parse_stmt_list_item);
self.parse_stmt_like(true, top_level)
}
/// Parse a statement, declaration or module item.
fn parse_stmt_like<Type>(&mut self, include_decl: bool, top_level: bool) -> PResult<Type>
where
Self: StmtLikeParser<'a, Type>,
Type: IsDirective + From<Stmt>,
{
trace_cur!(self, parse_stmt_like);
let _tracing = debug_tracing!(self, "parse_stmt_like");
let start = cur_pos!(self);
let decorators = self.parse_decorators(true)?;
if is_one_of!(self, "import", "export") {
return self.handle_import_export(top_level, decorators);
}
let ctx = Context {
will_expect_colon_for_cond: false,
allow_using_decl: true,
..self.ctx()
};
self.with_ctx(ctx)
.parse_stmt_internal(start, include_decl, top_level, decorators)
.map(From::from)
}
/// `parseStatementContent`
fn parse_stmt_internal(
&mut self,
start: BytePos,
include_decl: bool,
top_level: bool,
decorators: Vec<Decorator>,
) -> PResult<Stmt> {
trace_cur!(self, parse_stmt_internal);
let is_typescript = self.input.syntax().typescript();
if is_typescript && is!(self, "const") && peeked_is!(self, "enum") {
assert_and_bump!(self, "const");
assert_and_bump!(self, "enum");
return self
.parse_ts_enum_decl(start, true)
.map(Decl::from)
.map(Stmt::from);
}
match cur!(self, true) {
tok!("await") if include_decl || top_level => {
if top_level {
self.state.found_module_item = true;
if !self.ctx().can_be_module {
self.emit_err(self.input.cur_span(), SyntaxError::TopLevelAwaitInScript);
}
}
if peeked_is!(self, "using") {
let eaten_await = Some(self.input.cur_pos());
assert_and_bump!(self, "await");
let v = self.parse_using_decl(start, true)?;
if let Some(v) = v {
return Ok(v.into());
}
let expr = self.parse_await_expr(eaten_await)?;
let expr = self
.include_in_expr(true)
.parse_bin_op_recursively(expr, 0)?;
eat!(self, ';');
let span = span!(self, start);
return Ok(ExprStmt { span, expr }.into());
}
}
tok!("break") | tok!("continue") => {
let is_break = is!(self, "break");
bump!(self);
let label = if eat!(self, ';') {
None
} else {
let i = self.parse_label_ident().map(Some)?;
expect!(self, ';');
i
};
let span = span!(self, start);
if is_break {
if label.is_some() && !self.state.labels.contains(&label.as_ref().unwrap().sym)
{
self.emit_err(span, SyntaxError::TS1116);
} else if !self.ctx().is_break_allowed {
self.emit_err(span, SyntaxError::TS1105);
}
} else if !self.ctx().is_continue_allowed {
self.emit_err(span, SyntaxError::TS1115);
} else if label.is_some()
&& !self.state.labels.contains(&label.as_ref().unwrap().sym)
{
self.emit_err(span, SyntaxError::TS1107);
}
return Ok(if is_break {
BreakStmt { span, label }.into()
} else {
ContinueStmt { span, label }.into()
});
}
tok!("debugger") => {
bump!(self);
expect!(self, ';');
return Ok(DebuggerStmt {
span: span!(self, start),
}
.into());
}
tok!("do") => {
return self.parse_do_stmt();
}
tok!("for") => {
return self.parse_for_stmt();
}
tok!("function") => {
if !include_decl {
self.emit_err(self.input.cur_span(), SyntaxError::DeclNotAllowed);
}
return self.parse_fn_decl(decorators).map(Stmt::from);
}
tok!("class") => {
if !include_decl {
self.emit_err(self.input.cur_span(), SyntaxError::DeclNotAllowed);
}
return self
.parse_class_decl(start, start, decorators, false)
.map(Stmt::from);
}
tok!("if") => {
return self.parse_if_stmt().map(Stmt::If);
}
tok!("return") => {
return self.parse_return_stmt();
}
tok!("switch") => {
return self.parse_switch_stmt();
}
tok!("throw") => {
return self.parse_throw_stmt();
}
// Error recovery
tok!("catch") => {
let span = self.input.cur_span();
self.emit_err(span, SyntaxError::TS1005);
let _ = self.parse_catch_clause();
let _ = self.parse_finally_block();
return Ok(ExprStmt {
span,
expr: Invalid { span }.into(),
}
.into());
}
// Error recovery
tok!("finally") => {
let span = self.input.cur_span();
self.emit_err(span, SyntaxError::TS1005);
let _ = self.parse_finally_block();
return Ok(ExprStmt {
span,
expr: Invalid { span }.into(),
}
.into());
}
tok!("try") => {
return self.parse_try_stmt();
}
tok!("with") => {
return self.parse_with_stmt();
}
tok!("while") => {
return self.parse_while_stmt();
}
tok!("var") => {
let v = self.parse_var_stmt(false)?;
return Ok(v.into());
}
tok!("const") if include_decl => {
let v = self.parse_var_stmt(false)?;
return Ok(v.into());
}
// 'let' can start an identifier reference.
tok!("let") if include_decl => {
let strict = self.ctx().strict;
let is_keyword = match peek!(self) {
Some(t) => t.kind().follows_keyword_let(strict),
_ => false,
};
if is_keyword {
let v = self.parse_var_stmt(false)?;
return Ok(v.into());
}
}
tok!("using") if include_decl => {
let v = self.parse_using_decl(start, false)?;
if let Some(v) = v {
return Ok(v.into());
}
}
tok!("interface") => {
if is_typescript
&& peeked_is!(self, IdentName)
&& !self.input.has_linebreak_between_cur_and_peeked()
{
let start = self.input.cur_pos();
bump!(self);
return Ok(self.parse_ts_interface_decl(start)?.into());
}
}
tok!("type") => {
if is_typescript
&& peeked_is!(self, IdentName)
&& !self.input.has_linebreak_between_cur_and_peeked()
{
let start = self.input.cur_pos();
bump!(self);
return Ok(self.parse_ts_type_alias_decl(start)?.into());
}
}
tok!("enum") => {
if is_typescript
&& peeked_is!(self, IdentName)
&& !self.input.has_linebreak_between_cur_and_peeked()
{
let start = self.input.cur_pos();
bump!(self);
return Ok(self.parse_ts_enum_decl(start, false)?.into());
}
}
tok!('{') => {
let ctx = Context {
allow_using_decl: true,
..self.ctx()
};
return self.with_ctx(ctx).parse_block(false).map(Stmt::Block);
}
_ => {}
}
if eat_exact!(self, ';') {
return Ok(EmptyStmt {
span: span!(self, start),
}
.into());
}
// Handle async function foo() {}
if is!(self, "async")
&& peeked_is!(self, "function")
&& !self.input.has_linebreak_between_cur_and_peeked()
{
return self.parse_async_fn_decl(decorators).map(From::from);
}
// If the statement does not start with a statement keyword or a
// brace, it's an ExpressionStatement or LabeledStatement. We
// simply start parsing an expression, and afterwards, if the
// next token is a colon and the expression was a simple
// Identifier node, we switch to interpreting it as a label.
let expr = self.include_in_expr(true).parse_expr()?;
let expr = match *expr {
Expr::Ident(ident) => {
if eat!(self, ':') {
return self.parse_labelled_stmt(ident);
}
ident.into()
}
_ => self.verify_expr(expr)?,
};
if let Expr::Ident(ref ident) = *expr {
if &*ident.sym == "interface" && self.input.had_line_break_before_cur() {
self.emit_strict_mode_err(
ident.span,
SyntaxError::InvalidIdentInStrict(ident.sym.clone()),
);
eat!(self, ';');
return Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into());
}
if self.input.syntax().typescript() {
if let Some(decl) = self.parse_ts_expr_stmt(decorators, ident.clone())? {
return Ok(decl.into());
}
}
}
if let Expr::Ident(Ident { ref sym, span, .. }) = *expr {
match &**sym {
"enum" | "interface" => {
self.emit_strict_mode_err(span, SyntaxError::InvalidIdentInStrict(sym.clone()));
}
_ => {}
}
}
if self.syntax().typescript() {
if let Expr::Ident(ref i) = *expr {
match &*i.sym {
"public" | "static" | "abstract" => {
if eat!(self, "interface") {
self.emit_err(i.span, SyntaxError::TS2427);
return self
.parse_ts_interface_decl(start)
.map(Decl::from)
.map(Stmt::from);
}
}
_ => {}
}
}
}
if eat!(self, ';') {
Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into())
} else {
if let Token::BinOp(..) = *cur!(self, false)? {
self.emit_err(self.input.cur_span(), SyntaxError::TS1005);
let expr = self.parse_bin_op_recursively(expr, 0)?;
return Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into());
}
syntax_error!(
self,
SyntaxError::ExpectedSemiForExprStmt { expr: expr.span() }
);
}
}
/// Utility function used to parse large if else statements iteratively.
///
/// THis function is recursive, but it is very cheap so stack overflow will
/// not occur.
fn adjust_if_else_clause(&mut self, cur: &mut IfStmt, alt: Box<Stmt>) {
cur.span = span!(self, cur.span.lo);
if let Some(Stmt::If(prev_alt)) = cur.alt.as_deref_mut() {
self.adjust_if_else_clause(prev_alt, alt)
} else {
debug_assert_eq!(cur.alt, None);
cur.alt = Some(alt);
}
}
fn parse_if_stmt(&mut self) -> PResult<IfStmt> {
let start = cur_pos!(self);
assert_and_bump!(self, "if");
let if_token = self.input.prev_span();
expect!(self, '(');
let ctx = Context {
ignore_else_clause: false,
..self.ctx()
};
let test = self
.with_ctx(ctx)
.include_in_expr(true)
.parse_expr()
.map_err(|err| {
Error::new(
err.span(),
SyntaxError::WithLabel {
inner: Box::new(err),
span: if_token,
note: "Tried to parse the condition for an if statement",
},
)
})?;
expect!(self, ')');
let cons = {
// Prevent stack overflow
crate::maybe_grow(256 * 1024, 1024 * 1024, || {
// Annex B
if !self.ctx().strict && is!(self, "function") {
// TODO: report error?
}
let ctx = Context {
ignore_else_clause: false,
..self.ctx()
};
self.with_ctx(ctx).parse_stmt(false).map(Box::new)
})?
};
// We parse `else` branch iteratively, to avoid stack overflow
// See https://github.com/swc-project/swc/pull/3961
let alt = if self.ctx().ignore_else_clause {
None
} else {
let mut cur = None;
let ctx = Context {
ignore_else_clause: true,
..self.ctx()
};
let last = loop {
if !eat!(self, "else") {
break None;
}
if !is!(self, "if") {
let ctx = Context {
ignore_else_clause: false,
..self.ctx()
};
// As we eat `else` above, we need to parse statement once.
let last = self.with_ctx(ctx).parse_stmt(false)?;
break Some(last);
}
// We encountered `else if`
let alt = self.with_ctx(ctx).parse_if_stmt()?;
match &mut cur {
Some(cur) => {
self.adjust_if_else_clause(cur, Box::new(alt.into()));
}
_ => {
cur = Some(alt);
}
}
};
match cur {
Some(mut cur) => {
if let Some(last) = last {
self.adjust_if_else_clause(&mut cur, Box::new(last));
}
Some(cur.into())
}
_ => last,
}
}
.map(Box::new);
let span = span!(self, start);
Ok(IfStmt {
span,
test,
cons,
alt,
})
}
fn parse_return_stmt(&mut self) -> PResult<Stmt> {
let start = cur_pos!(self);
let stmt = self.parse_with(|p| {
assert_and_bump!(p, "return");
let arg = if is!(p, ';') {
None
} else {
p.include_in_expr(true).parse_expr().map(Some)?
};
expect!(p, ';');
Ok(ReturnStmt {
span: span!(p, start),
arg,
}
.into())
});
if !self.ctx().in_function && !self.input.syntax().allow_return_outside_function() {
self.emit_err(span!(self, start), SyntaxError::ReturnNotAllowed);
}
stmt
}
fn parse_switch_stmt(&mut self) -> PResult<Stmt> {
let switch_start = cur_pos!(self);
assert_and_bump!(self, "switch");
expect!(self, '(');
let discriminant = self.include_in_expr(true).parse_expr()?;
expect!(self, ')');
let mut cases = Vec::new();
let mut span_of_previous_default = None;
expect!(self, '{');
let ctx = Context {
is_break_allowed: true,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
while is_one_of!(p, "case", "default") {
let mut cons = Vec::new();
let is_case = is!(p, "case");
let case_start = cur_pos!(p);
bump!(p);
let test = if is_case {
p.include_in_expr(true).parse_expr().map(Some)?
} else {
if let Some(previous) = span_of_previous_default {
syntax_error!(p, SyntaxError::MultipleDefault { previous });
}
span_of_previous_default = Some(span!(p, case_start));
None
};
expect!(p, ':');
while !eof!(p) && !is_one_of!(p, "case", "default", '}') {
cons.push(p.parse_stmt_list_item(false)?);
}
cases.push(SwitchCase {
span: Span::new(case_start, p.input.prev_span().hi),
test,
cons,
});
}
Ok(())
})?;
// eof or rbrace
expect!(self, '}');
Ok(SwitchStmt {
span: span!(self, switch_start),
discriminant,
cases,
}
.into())
}
fn parse_throw_stmt(&mut self) -> PResult<Stmt> {
let start = cur_pos!(self);
assert_and_bump!(self, "throw");
if self.input.had_line_break_before_cur() {
// TODO: Suggest throw arg;
syntax_error!(self, SyntaxError::LineBreakInThrow);
}
let arg = self.include_in_expr(true).parse_expr()?;
expect!(self, ';');
let span = span!(self, start);
Ok(ThrowStmt { span, arg }.into())
}
fn parse_try_stmt(&mut self) -> PResult<Stmt> {
let start = cur_pos!(self);
assert_and_bump!(self, "try");
let block = self.parse_block(false)?;
let catch_start = cur_pos!(self);
let handler = self.parse_catch_clause()?;
let finalizer = self.parse_finally_block()?;
if handler.is_none() && finalizer.is_none() {
self.emit_err(Span::new(catch_start, catch_start), SyntaxError::TS1005);
}
let span = span!(self, start);
Ok(TryStmt {
span,
block,
handler,
finalizer,
}
.into())
}
fn parse_catch_clause(&mut self) -> PResult<Option<CatchClause>> {
let start = cur_pos!(self);
Ok(if eat!(self, "catch") {
let param = self.parse_catch_param()?;
self.parse_block(false)
.map(|body| CatchClause {
span: span!(self, start),
param,
body,
})
.map(Some)?
} else {
None
})
}
fn parse_finally_block(&mut self) -> PResult<Option<BlockStmt>> {
Ok(if eat!(self, "finally") {
self.parse_block(false).map(Some)?
} else {
None
})
}
/// It's optional since es2019
fn parse_catch_param(&mut self) -> PResult<Option<Pat>> {
if eat!(self, '(') {
let mut pat = self.parse_binding_pat_or_ident(false)?;
let type_ann_start = cur_pos!(self);
if self.syntax().typescript() && eat!(self, ':') {
let ctx = Context {
in_type: true,
..self.ctx()
};
let ty = self.with_ctx(ctx).parse_with(|p| p.parse_ts_type())?;
// self.emit_err(ty.span(), SyntaxError::TS1196);
match &mut pat {
Pat::Ident(BindingIdent { type_ann, .. })
| Pat::Array(ArrayPat { type_ann, .. })
| Pat::Rest(RestPat { type_ann, .. })
| Pat::Object(ObjectPat { type_ann, .. }) => {
*type_ann = Some(Box::new(TsTypeAnn {
span: span!(self, type_ann_start),
type_ann: ty,
}));
}
Pat::Assign(..) => {}
Pat::Invalid(_) => {}
Pat::Expr(_) => {}
}
}
expect!(self, ')');
Ok(Some(pat))
} else {
Ok(None)
}
}
pub(super) fn parse_using_decl(
&mut self,
start: BytePos,
is_await: bool,
) -> PResult<Option<Box<UsingDecl>>> {
// using
// reader = init()
// is two statements
let _ = cur!(self, false);
if self.input.has_linebreak_between_cur_and_peeked() {
return Ok(None);
}
if !peeked_is!(self, BindingIdent) {
return Ok(None);
}
assert_and_bump!(self, "using");
let mut decls = Vec::new();
let mut first = true;
while first || eat!(self, ',') {
if first {
first = false;
}
// Handle
// var a,;
//
// NewLine is ok
if is_exact!(self, ';') || eof!(self) {
let span = self.input.prev_span();
self.emit_err(span, SyntaxError::TS1009);
break;
}
decls.push(self.parse_var_declarator(false, VarDeclKind::Var)?);
}
if !self.syntax().explicit_resource_management() {
self.emit_err(span!(self, start), SyntaxError::UsingDeclNotEnabled);
}
if !self.ctx().allow_using_decl {
self.emit_err(span!(self, start), SyntaxError::UsingDeclNotAllowed);
}
for decl in &decls {
match decl.name {
Pat::Ident(..) => {}
_ => {
self.emit_err(span!(self, start), SyntaxError::InvalidNameInUsingDecl);
}
}
if decl.init.is_none() {
self.emit_err(span!(self, start), SyntaxError::InitRequiredForUsingDecl);
}
}
eat!(self, ';');
Ok(Some(Box::new(UsingDecl {
span: span!(self, start),
is_await,
decls,
})))
}
pub(super) fn parse_var_stmt(&mut self, for_loop: bool) -> PResult<Box<VarDecl>> {
let start = cur_pos!(self);
let kind = match bump!(self) {
tok!("const") => VarDeclKind::Const,
tok!("let") => VarDeclKind::Let,
tok!("var") => VarDeclKind::Var,
_ => unreachable!(),
};
let var_span = span!(self, start);
let should_include_in = kind != VarDeclKind::Var || !for_loop;
if self.syntax().typescript() && for_loop {
let res = if is_one_of!(self, "in", "of") {
self.ts_look_ahead(|p| {
//
if !eat!(p, "of") && !eat!(p, "in") {
return Ok(false);
}
p.parse_assignment_expr()?;
expect!(p, ')');
Ok(true)
})
} else {
Ok(false)
};
match res {
Ok(true) => {
let pos = var_span.hi();
let span = Span::new(pos, pos);
self.emit_err(span, SyntaxError::TS1123);
return Ok(Box::new(VarDecl {
span: span!(self, start),
kind,
declare: false,
decls: Vec::new(),
..Default::default()
}));
}
Err(..) => {}
_ => {}
}
}
let mut decls = Vec::new();
let mut first = true;
while first || eat!(self, ',') {
if first {
first = false;
}
let ctx = if should_include_in {
Context {
include_in_expr: true,
..self.ctx()
}
} else {
self.ctx()
};
// Handle
// var a,;
//
// NewLine is ok
if is_exact!(self, ';') || eof!(self) {
let prev_span = self.input.prev_span();
let span = if prev_span == var_span {
Span::new(prev_span.hi, prev_span.hi)
} else {
prev_span
};
self.emit_err(span, SyntaxError::TS1009);
break;
}
decls.push(self.with_ctx(ctx).parse_var_declarator(for_loop, kind)?);
}
if !for_loop && !eat!(self, ';') {
self.emit_err(self.input.cur_span(), SyntaxError::TS1005);
let _ = self.parse_expr();
while !eat!(self, ';') {
bump!(self);
if let Some(Token::Error(_)) = self.input.cur() {
break;
}
}
}
Ok(Box::new(VarDecl {
span: span!(self, start),
declare: false,
kind,
decls,
..Default::default()
}))
}
fn parse_var_declarator(
&mut self,
for_loop: bool,
kind: VarDeclKind,
) -> PResult<VarDeclarator> {
let start = cur_pos!(self);
let is_let_or_const = matches!(kind, VarDeclKind::Let | VarDeclKind::Const);
let mut name = self.parse_binding_pat_or_ident(is_let_or_const)?;
let definite = if self.input.syntax().typescript() {
match name {
Pat::Ident(..) => eat!(self, '!'),
_ => false,
}
} else {
false
};
// Typescript extension
if self.input.syntax().typescript() && is!(self, ':') {
let type_annotation = self.try_parse_ts_type_ann()?;
match name {
Pat::Array(ArrayPat {
ref mut type_ann, ..
})
| Pat::Ident(BindingIdent {
ref mut type_ann, ..
})
| Pat::Object(ObjectPat {
ref mut type_ann, ..
})
| Pat::Rest(RestPat {
ref mut type_ann, ..
}) => {
*type_ann = type_annotation;
}
_ => unreachable!("invalid syntax: Pat: {:?}", name),
}
}
//FIXME: This is wrong. Should check in/of only on first loop.
let init = if !for_loop || !is_one_of!(self, "in", "of") {
if eat!(self, '=') {
let expr = self.parse_assignment_expr()?;
let expr = self.verify_expr(expr)?;
Some(expr)
} else {
// Destructuring bindings require initializers, but
// typescript allows `declare` vars not to have initializers.
if self.ctx().in_declare {
None
} else if kind == VarDeclKind::Const && !for_loop && !self.ctx().in_declare {
self.emit_err(
span!(self, start),
SyntaxError::ConstDeclarationsRequireInitialization,
);
None
} else {
match name {
Pat::Ident(..) => None,
_ => {
syntax_error!(self, span!(self, start), SyntaxError::PatVarWithoutInit)
}
}
}
}
} else {
// e.g. for(let a;;)
None
};
Ok(VarDeclarator {
span: span!(self, start),
name,
init,
definite,
})
}
fn parse_do_stmt(&mut self) -> PResult<Stmt> {
let start = cur_pos!(self);
assert_and_bump!(self, "do");
let ctx = Context {
is_break_allowed: true,
is_continue_allowed: true,
..self.ctx()
};
let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;
expect!(self, "while");
expect!(self, '(');
let test = self.include_in_expr(true).parse_expr()?;
expect!(self, ')');
// We *may* eat semicolon.
let _ = eat!(self, ';');
let span = span!(self, start);
Ok(DoWhileStmt { span, test, body }.into())
}
fn parse_while_stmt(&mut self) -> PResult<Stmt> {
let start = cur_pos!(self);
assert_and_bump!(self, "while");
expect!(self, '(');
let test = self.include_in_expr(true).parse_expr()?;
expect!(self, ')');
let ctx = Context {
is_break_allowed: true,
is_continue_allowed: true,
..self.ctx()
};
let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;
let span = span!(self, start);
Ok(WhileStmt { span, test, body }.into())
}
fn parse_with_stmt(&mut self) -> PResult<Stmt> {
if self.syntax().typescript() {
let span = self.input.cur_span();
self.emit_err(span, SyntaxError::TS2410);
}
{
let span = self.input.cur_span();
self.emit_strict_mode_err(span, SyntaxError::WithInStrict);
}
let start = cur_pos!(self);
assert_and_bump!(self, "with");
expect!(self, '(');
let obj = self.include_in_expr(true).parse_expr()?;
expect!(self, ')');
let ctx = Context {
in_function: true,
..self.ctx()
};
let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;
let span = span!(self, start);
Ok(WithStmt { span, obj, body }.into())
}
pub(super) fn parse_block(&mut self, allow_directives: bool) -> PResult<BlockStmt> {
let start = cur_pos!(self);
expect!(self, '{');
let stmts = self.parse_block_body(allow_directives, false, Some(&tok!('}')))?;
let span = span!(self, start);
Ok(BlockStmt {
span,
stmts,
ctxt: Default::default(),
})
}
fn parse_labelled_stmt(&mut self, l: Ident) -> PResult<Stmt> {
let ctx = Context {
is_break_allowed: true,
allow_using_decl: false,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
let start = l.span.lo();
let mut errors = Vec::new();
for lb in &p.state.labels {
if l.sym == *lb {
errors.push(Error::new(
l.span,
SyntaxError::DuplicateLabel(l.sym.clone()),
));
}
}
p.state.labels.push(l.sym.clone());
let body = Box::new(if is!(p, "function") {
let f = p.parse_fn_decl(Vec::new())?;
if let Decl::Fn(FnDecl { function, .. }) = &f {
if p.ctx().strict {
p.emit_err(function.span, SyntaxError::LabelledFunctionInStrict)
}
if function.is_generator || function.is_async {
p.emit_err(function.span, SyntaxError::LabelledGeneratorOrAsync)
}
}
f.into()
} else {
p.parse_stmt(false)?
});
for err in errors {
p.emit_error(err);
}
{
let pos = p.state.labels.iter().position(|v| v == &l.sym);
if let Some(pos) = pos {
p.state.labels.remove(pos);
}
}
Ok(LabeledStmt {
span: span!(p, start),
label: l,
body,
}
.into())
})
}
fn parse_for_stmt(&mut self) -> PResult<Stmt> {
let start = cur_pos!(self);
assert_and_bump!(self, "for");
let await_start = cur_pos!(self);
let await_token = if eat!(self, "await") {
Some(span!(self, await_start))
} else {
None
};
expect!(self, '(');
let mut ctx = self.ctx();
ctx.expr_ctx.for_loop_init = true;
ctx.expr_ctx.for_await_loop_init = await_token.is_some();
let head = self.with_ctx(ctx).parse_for_head()?;
expect!(self, ')');
let ctx = Context {
is_break_allowed: true,
is_continue_allowed: true,
..self.ctx()
};
let body = self.with_ctx(ctx).parse_stmt(false).map(Box::new)?;
let span = span!(self, start);
Ok(match head {
TempForHead::For { init, test, update } => {
if let Some(await_token) = await_token {
syntax_error!(self, await_token, SyntaxError::AwaitForStmt);
}
ForStmt {
span,
init,
test,
update,
body,
}
.into()
}
TempForHead::ForIn { left, right } => {
if let Some(await_token) = await_token {
syntax_error!(self, await_token, SyntaxError::AwaitForStmt);
}
ForInStmt {
span,
left,
right,
body,
}
.into()
}
TempForHead::ForOf { left, right } => ForOfStmt {
span,
is_await: await_token.is_some(),
left,
right,
body,
}
.into(),
})
}
fn parse_for_head(&mut self) -> PResult<TempForHead> {
let strict = self.ctx().strict;
if is_one_of!(self, "const", "var")
|| (is!(self, "let")
&& peek!(self).map_or(false, |v| v.kind().follows_keyword_let(strict)))
{
let decl = self.parse_var_stmt(true)?;
if is_one_of!(self, "of", "in") {
if decl.decls.len() != 1 {
for d in decl.decls.iter().skip(1) {
self.emit_err(d.name.span(), SyntaxError::TooManyVarInForInHead);
}
} else {
if (self.ctx().strict || is!(self, "of")) && decl.decls[0].init.is_some() {
self.emit_err(
decl.decls[0].name.span(),
SyntaxError::VarInitializerInForInHead,
);
}
if self.syntax().typescript() {
let type_ann = match decl.decls[0].name {
Pat::Ident(ref v) => Some(&v.type_ann),
Pat::Array(ref v) => Some(&v.type_ann),
Pat::Rest(ref v) => Some(&v.type_ann),
Pat::Object(ref v) => Some(&v.type_ann),
_ => None,
};
if let Some(type_ann) = type_ann {
if type_ann.is_some() {
self.emit_err(decl.decls[0].name.span(), SyntaxError::TS2483);
}
}
}
}
return self.parse_for_each_head(ForHead::VarDecl(decl));
}
expect_exact!(self, ';');
return self.parse_normal_for_head(Some(VarDeclOrExpr::VarDecl(decl)));
}
if eat_exact!(self, ';') {
return self.parse_normal_for_head(None);
}
let start = cur_pos!(self);
let init = self.include_in_expr(false).parse_for_head_prefix()?;
let mut is_using_decl = false;
let mut is_await_using_decl = false;
if self.input.syntax().explicit_resource_management() {
// using foo
let mut maybe_using_decl = init.is_ident_ref_to("using");
let mut maybe_await_using_decl = false;
// await using foo
if !maybe_using_decl
&& init
.as_await_expr()
.filter(|e| e.arg.is_ident_ref_to("using"))
.is_some()
{
maybe_using_decl = true;
maybe_await_using_decl = true;
}
if maybe_using_decl
&& !is!(self, "of")
&& (peeked_is!(self, "of") || peeked_is!(self, "in"))
{
is_using_decl = maybe_using_decl;
is_await_using_decl = maybe_await_using_decl;
}
}
if is_using_decl {
let name = self.parse_binding_ident(false)?;
let decl = VarDeclarator {
name: name.into(),
span: span!(self, start),
init: None,
definite: false,
};
let pat = Box::new(UsingDecl {
span: span!(self, start),
is_await: is_await_using_decl,
decls: vec![decl],
});
cur!(self, true);
return self.parse_for_each_head(ForHead::UsingDecl(pat));
}
// for (a of b)
if is_one_of!(self, "of", "in") {
let is_in = is!(self, "in");
let pat = self.reparse_expr_as_pat(PatType::AssignPat, init)?;
// for ({} in foo) is invalid
if self.input.syntax().typescript() && is_in {
match pat {
Pat::Ident(..) => {}
Pat::Expr(..) => {}
ref v => self.emit_err(v.span(), SyntaxError::TS2491),
}
}
return self.parse_for_each_head(ForHead::Pat(Box::new(pat)));
}
expect_exact!(self, ';');
let init = self.verify_expr(init)?;
self.parse_normal_for_head(Some(VarDeclOrExpr::Expr(init)))
}
fn parse_for_each_head(&mut self, left: ForHead) -> PResult<TempForHead> {
let is_of = bump!(self) == tok!("of");
if is_of {
let right = self.include_in_expr(true).parse_assignment_expr()?;
Ok(TempForHead::ForOf { left, right })
} else {
if let ForHead::UsingDecl(d) = &left {
self.emit_err(d.span, SyntaxError::UsingDeclNotAllowedForForInLoop)
}
let right = self.include_in_expr(true).parse_expr()?;
Ok(TempForHead::ForIn { left, right })
}
}
fn parse_normal_for_head(&mut self, init: Option<VarDeclOrExpr>) -> PResult<TempForHead> {
let test = if eat_exact!(self, ';') {
None
} else {
let test = self.include_in_expr(true).parse_expr().map(Some)?;
expect_exact!(self, ';');
test
};
let update = if is!(self, ')') {
None
} else {
self.include_in_expr(true).parse_expr().map(Some)?
};
Ok(TempForHead::For { init, test, update })
}
}
#[allow(clippy::enum_variant_names)]
enum TempForHead {
For {
init: Option<VarDeclOrExpr>,
test: Option<Box<Expr>>,
update: Option<Box<Expr>>,
},
ForIn {
left: ForHead,
right: Box<Expr>,
},
ForOf {
left: ForHead,
right: Box<Expr>,
},
}
pub(super) trait IsDirective {
fn as_ref(&self) -> Option<&Stmt>;
fn is_use_strict(&self) -> bool {
self.as_ref().map_or(false, Stmt::is_use_strict)
}
}
impl<T> IsDirective for Box<T>
where
T: IsDirective,
{
fn as_ref(&self) -> Option<&Stmt> {
T::as_ref(&**self)
}
}
impl IsDirective for Stmt {
fn as_ref(&self) -> Option<&Stmt> {
Some(self)
}
}
pub(super) trait StmtLikeParser<'a, Type: IsDirective> {
fn handle_import_export(
&mut self,
top_level: bool,
decorators: Vec<Decorator>,
) -> PResult<Type>;
}
impl<'a, I: Tokens, T> StmtLikeParser<'a, Box<T>> for Parser<I>
where
T: IsDirective,
Self: StmtLikeParser<'a, T>,
{
fn handle_import_export(
&mut self,
top_level: bool,
decorators: Vec<Decorator>,
) -> PResult<Box<T>> {
<Self as StmtLikeParser<T>>::handle_import_export(self, top_level, decorators).map(Box::new)
}
}
impl<I: Tokens> StmtLikeParser<'_, Stmt> for Parser<I> {
fn handle_import_export(&mut self, _: bool, _: Vec<Decorator>) -> PResult<Stmt> {
let start = cur_pos!(self);
if is!(self, "import") && peeked_is!(self, '(') {
let expr = self.parse_expr()?;
eat!(self, ';');
return Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into());
}
if is!(self, "import") && peeked_is!(self, '.') {
let expr = self.parse_expr()?;
eat!(self, ';');
return Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into());
}
syntax_error!(self, SyntaxError::ImportExportInScript);
}
}
#[cfg(test)]
mod tests {
use swc_common::{comments::SingleThreadedComments, DUMMY_SP as span};
use swc_ecma_visit::assert_eq_ignore_span;
use super::*;
use crate::EsSyntax;
fn stmt(s: &'static str) -> Stmt {
test_parser(s, Syntax::default(), |p| p.parse_stmt(true))
}
fn module_item(s: &'static str) -> ModuleItem {
test_parser(s, Syntax::default(), |p| p.parse_stmt_like(true, true))
}
fn expr(s: &'static str) -> Box<Expr> {
test_parser(s, Syntax::default(), |p| p.parse_expr())
}
#[test]
fn expr_stmt() {
assert_eq_ignore_span!(
stmt("a + b + c"),
Stmt::Expr(ExprStmt {
span,
expr: expr("a + b + c")
})
)
}
#[test]
fn catch_rest_pat() {
assert_eq_ignore_span!(
stmt("try {} catch({ ...a34 }) {}"),
Stmt::Try(Box::new(TryStmt {
span,
block: BlockStmt {
span,
..Default::default()
},
handler: Some(CatchClause {
span,
param: Pat::Object(ObjectPat {
span,
optional: false,
props: vec![ObjectPatProp::Rest(RestPat {
span,
dot3_token: span,
arg: Box::new(Pat::Ident(
Ident::new_no_ctxt("a34".into(), span).into()
)),
type_ann: None
})],
type_ann: None,
})
.into(),
body: BlockStmt {
span,
..Default::default()
}
}),
finalizer: None
}))
);
}
#[test]
fn throw_this() {
assert_eq_ignore_span!(
stmt("throw this"),
Stmt::Throw(ThrowStmt {
span,
arg: expr("this"),
})
)
}
#[test]
fn await_for_of() {
assert_eq_ignore_span!(
stmt("for await (const a of b) ;"),
Stmt::ForOf(ForOfStmt {
span,
is_await: true,
left: ForHead::VarDecl(Box::new(VarDecl {
span,
kind: VarDeclKind::Const,
decls: vec![VarDeclarator {
span,
init: None,
name: Pat::Ident(Ident::new_no_ctxt("a".into(), span).into()),
definite: false,
}],
..Default::default()
})),
right: Box::new(Expr::Ident(Ident::new_no_ctxt("b".into(), span))),
body: Box::new(Stmt::Empty(EmptyStmt { span })),
})
)
}
#[test]
fn no_empty_without_semi() {
assert_eq_ignore_span!(
stmt("(function foo() { return 1 })"),
stmt(
"(function foo () {
return 1
})"
)
);
assert_eq_ignore_span!(
stmt("{ 1; }"),
Stmt::Block(BlockStmt {
span,
stmts: vec![stmt("1")],
..Default::default()
})
);
}
#[test]
fn if_else() {
assert_eq_ignore_span!(
stmt("if (a) b; else c"),
Stmt::If(IfStmt {
span,
test: expr("a"),
cons: Box::new(stmt("b;")),
alt: Some(Box::new(stmt("c"))),
})
);
}
#[test]
fn class_decorator() {
assert_eq_ignore_span!(
test_parser(
"
@decorator
@dec2
class Foo {}
",
Syntax::Es(EsSyntax {
decorators: true,
..Default::default()
}),
|p| p.parse_stmt_list_item(true),
),
Stmt::Decl(Decl::Class(ClassDecl {
ident: Ident::new_no_ctxt("Foo".into(), span),
class: Box::new(Class {
span,
decorators: vec![
Decorator {
span,
expr: expr("decorator")
},
Decorator {
span,
expr: expr("dec2")
}
],
super_class: None,
body: Vec::new(),
is_abstract: false,
..Default::default()
}),
declare: false,
}))
);
}
#[test]
fn example() {
let src = r#"
import React from 'react'
import ReactDOM from 'react-dom'
function App() {
return <h1>JSX is working!</h1>
}
ReactDOM.render(<App />, document.getElementById('root'))
"#;
test_parser(
src,
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn ice() {
let src = r#"import React from "react"
function App() {
return <h1>works</h1>
}
export default App"#;
test_parser(
src,
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn export_default() {
let src = "export v, { x, y as w } from 'mod';";
test_parser(
src,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn export_default_2() {
let src = "export foo from 'bar';";
test_parser(
src,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn export_default_3() {
let src = "export default from 'bar';";
test_parser(
src,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn export_default_4() {
let src = "export default, {foo} from 'bar';";
test_parser(
src,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn shebang_01() {
let src = "#!/usr/bin/env node";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn shebang_02() {
let src = "#!/usr/bin/env node
let x = 4";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn empty() {
test_parser("", Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn issue_226() {
test_parser(
"export * as Foo from 'bar';",
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
#[should_panic(expected = "Expected 'from', got ','")]
fn issue_4369_1() {
test_parser(
r#"export * as foo, { bar } from "mod""#,
Syntax::Es(EsSyntax {
export_default_from: false,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn issue_4369_2() {
test_parser(
r#"export foo, * as bar, { baz } from "mod""#,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn issue_4369_3() {
test_parser(
r#"export foo, * as bar from "mod""#,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn issue_4369_4() {
test_parser(
r#"export * as bar, { baz } from "mod""#,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn issue_4369_5() {
test_parser(
r#"export foo, { baz } from "mod""#,
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
#[test]
fn issue_257_var() {
test_parser(
"
export default function waitUntil(callback, options = {}) {
var timeout = 'timeout' in options ? options.timeout : 1000;
}",
Default::default(),
|p| p.parse_module(),
);
}
#[test]
fn issue_257_let() {
test_parser(
"
export default function waitUntil(callback, options = {}) {
let timeout = 'timeout' in options ? options.timeout : 1000;
}",
Default::default(),
|p| p.parse_module(),
);
}
#[test]
fn issue_269() {
test_parser(
";(function() {})(window, window.lib || (window.lib = {}))",
Default::default(),
|p| p.parse_module(),
);
}
#[test]
fn issue_319_2() {
module_item(
"export default obj({
async f() {
await g();
}
});",
);
}
#[test]
fn issue_340_fn() {
test_parser("export default function(){};", Default::default(), |p| {
p.parse_module()
});
}
#[test]
fn issue_340_async_fn() {
test_parser(
"export default async function(){};",
Default::default(),
|p| p.parse_module(),
);
}
#[test]
fn issue_340_generator_fn() {
test_parser("export default function*(){};", Default::default(), |p| {
p.parse_module()
});
}
#[test]
fn issue_340_class() {
test_parser("export default class {};", Default::default(), |p| {
p.parse_module()
});
}
#[test]
fn issue_360() {
test_parser(
"var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;",
Default::default(),
|p| p.parse_module(),
);
}
#[test]
fn issue_380_1() {
test_parser(
"import(filePath).then(bar => {})",
Syntax::Es(Default::default()),
|p| p.parse_module(),
);
}
#[test]
fn issue_380_2() {
test_parser(
"class Foo {
componentDidMount() {
const filePath = '../foo/bar'
import(filePath).then(bar => {})
}
}",
Syntax::Es(Default::default()),
|p| p.parse_module(),
);
}
#[test]
fn issue_411() {
test_parser(
"try {
} catch {}",
Syntax::Es(Default::default()),
|p| p.parse_module(),
);
}
#[test]
fn top_level_await() {
test_parser("await foo", Syntax::Es(Default::default()), |p| {
p.parse_module()
});
}
#[test]
fn issue_856() {
let c = SingleThreadedComments::default();
let s = "class Foo {
static _extensions: {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
[key: string]: (module: Module, filename: string) => any;
} = Object.create(null);
}
";
let _ = test_parser_comment(&c, s, Syntax::Typescript(Default::default()), |p| {
p.parse_typescript_module()
});
let (leading, trailing) = c.take_all();
assert!(trailing.borrow().is_empty());
assert_eq!(leading.borrow().len(), 1);
}
#[test]
fn issue_856_2() {
let c = SingleThreadedComments::default();
let s = "type ConsoleExamineFunc = (
// eslint-disable-next-line @typescript-eslint/no-explicit-any
csl: any,
out: StringBuffer,
err?: StringBuffer,
both?: StringBuffer
) => void;";
let _ = test_parser_comment(&c, s, Syntax::Typescript(Default::default()), |p| {
p.parse_typescript_module()
});
let (leading, trailing) = c.take_all();
assert!(trailing.borrow().is_empty());
assert_eq!(leading.borrow().len(), 1);
}
#[test]
fn issue_856_3() {
let c = SingleThreadedComments::default();
let s = "type RequireWrapper = (
// eslint-disable-next-line @typescript-eslint/no-explicit-any
exports: any,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
require: any,
module: Module,
__filename: string,
__dirname: string
) => void;";
let _ = test_parser_comment(&c, s, Syntax::Typescript(Default::default()), |p| {
p.parse_typescript_module()
});
let (leading, trailing) = c.take_all();
assert!(trailing.borrow().is_empty());
assert_eq!(leading.borrow().len(), 2);
}
#[test]
fn issue_856_4() {
let c = SingleThreadedComments::default();
let s = "const _extensions: {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
[key: string]: (module: Module, filename: string) => any;
} = Object.create(null);";
let _ = test_parser_comment(&c, s, Syntax::Typescript(Default::default()), |p| {
p.parse_typescript_module()
});
let (leading, trailing) = c.take_all();
assert!(trailing.borrow().is_empty());
assert_eq!(leading.borrow().len(), 1);
}
fn parse_for_head(str: &'static str) -> TempForHead {
test_parser(str, Syntax::default(), |p| p.parse_for_head())
}
#[test]
fn for_array_binding_pattern() {
match parse_for_head("let [, , t] = simple_array; t < 10; t++") {
TempForHead::For { init: Some(v), .. } => assert_eq_ignore_span!(
v,
VarDeclOrExpr::VarDecl(Box::new(VarDecl {
span,
declare: false,
kind: VarDeclKind::Let,
decls: vec![VarDeclarator {
span,
name: Pat::Array(ArrayPat {
span,
type_ann: None,
optional: false,
elems: vec![
None,
None,
Some(Pat::Ident(Ident::new_no_ctxt("t".into(), span).into()))
]
}),
init: Some(Box::new(Expr::Ident(Ident::new_no_ctxt(
"simple_array".into(),
span
)))),
definite: false
}],
..Default::default()
}))
),
_ => unreachable!(),
}
}
#[test]
fn for_object_binding_pattern() {
match parse_for_head("let {num} = obj; num < 11; num++") {
TempForHead::For { init: Some(v), .. } => assert_eq_ignore_span!(
v,
VarDeclOrExpr::VarDecl(Box::new(VarDecl {
span,
kind: VarDeclKind::Let,
decls: vec![VarDeclarator {
span,
name: Pat::Object(ObjectPat {
optional: false,
type_ann: None,
span,
props: vec![ObjectPatProp::Assign(AssignPatProp {
span,
key: Ident::new_no_ctxt("num".into(), span).into(),
value: None
})]
}),
init: Some(Box::new(Expr::Ident(Ident::new_no_ctxt(
"obj".into(),
span
)))),
definite: false
}],
..Default::default()
}))
),
_ => unreachable!(),
}
}
#[test]
#[should_panic(expected = "'import.meta' cannot be used outside of module code.")]
fn import_meta_in_script() {
let src = "const foo = import.meta.url;";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
fn import_meta_in_program() {
let src = "const foo = import.meta.url;";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_program());
}
#[test]
#[should_panic(expected = "'import', and 'export' cannot be used outside of module code")]
fn import_statement_in_script() {
let src = "import 'foo';";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
#[should_panic(expected = "top level await is only allowed in module")]
fn top_level_await_in_script() {
let src = "await promise";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
fn top_level_await_in_program() {
let src = "await promise";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_program());
}
#[test]
fn for_of_head_lhs_async_dot() {
let src = "for (async.x of [1]) ;";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn for_head_init_async_of() {
let src = "for (async of => {}; i < 10; ++i) { ++counter; }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
#[should_panic(expected = "await isn't allowed in non-async function")]
fn await_in_function_in_module() {
let src = "function foo (p) { await p; }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
#[should_panic(expected = "await isn't allowed in non-async function")]
fn await_in_function_in_script() {
let src = "function foo (p) { await p; }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
#[should_panic(expected = "await isn't allowed in non-async function")]
fn await_in_function_in_program() {
let src = "function foo (p) { await p; }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_program());
}
#[test]
#[should_panic(expected = "`await` cannot be used as an identifier in an async context")]
fn await_in_nested_async_function_in_module() {
let src = "async function foo () { function bar(x = await) {} }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn await_in_nested_async_function_in_script() {
let src = "async function foo () { function bar(x = await) {} }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
fn await_in_nested_async_function_in_program() {
let src = "async function foo () { function bar(x = await) {} }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_program());
}
#[test]
#[should_panic(expected = "`await` cannot be used as an identifier in an async context")]
fn await_as_param_ident_in_module() {
let src = "function foo (x = await) { }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn await_as_param_ident_in_script() {
let src = "function foo (x = await) { }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
#[should_panic(expected = "`await` cannot be used as an identifier in an async context")]
fn await_as_ident_in_module() {
let src = "let await = 1";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn await_as_ident_in_script() {
let src = "let await = 1";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
#[should_panic(expected = "`await` cannot be used as an identifier in an async context")]
fn await_as_ident_in_async() {
let src = "async function foo() { let await = 1; }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
fn top_level_await_in_block() {
let src = "if (true) { await promise; }";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
fn class_static_blocks() {
let src = "class Foo { static { 1 + 1; } }";
assert_eq_ignore_span!(
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr()),
Box::new(Expr::Class(ClassExpr {
ident: Some(Ident {
span,
sym: "Foo".into(),
..Default::default()
}),
class: Box::new(Class {
span,
decorators: Vec::new(),
super_class: None,
type_params: None,
super_type_params: None,
is_abstract: false,
implements: Vec::new(),
body: vec!(ClassMember::StaticBlock(StaticBlock {
span,
body: BlockStmt {
span,
stmts: vec!(stmt("1 + 1;")),
..Default::default()
}
})),
..Default::default()
})
}))
);
}
#[test]
fn multiple_class_static_blocks() {
let src = "class Foo { static { 1 + 1; } static { 1 + 1; } }";
assert_eq_ignore_span!(
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr()),
Box::new(Expr::Class(ClassExpr {
ident: Some(Ident {
span,
sym: "Foo".into(),
..Default::default()
}),
class: Box::new(Class {
span,
decorators: Vec::new(),
super_class: None,
is_abstract: false,
body: vec!(
ClassMember::StaticBlock(StaticBlock {
span,
body: BlockStmt {
span,
stmts: vec!(stmt("1 + 1;")),
..Default::default()
},
}),
ClassMember::StaticBlock(StaticBlock {
span,
body: BlockStmt {
span,
stmts: vec!(stmt("1 + 1;")),
..Default::default()
},
})
),
..Default::default()
})
}))
);
}
#[test]
fn class_static_blocks_with_line_breaks_01() {
let src = "class Foo {
static
{
1 + 1;
}
}";
assert_eq_ignore_span!(
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr()),
Box::new(Expr::Class(ClassExpr {
ident: Some(Ident {
span,
sym: "Foo".into(),
..Default::default()
}),
class: Box::new(Class {
span,
is_abstract: false,
body: vec!(ClassMember::StaticBlock(StaticBlock {
span,
body: BlockStmt {
span,
stmts: vec!(stmt("1 + 1;")),
..Default::default()
}
})),
..Default::default()
})
}))
);
}
#[test]
fn class_static_blocks_with_line_breaks_02() {
let src = "class Foo {
static
{}
}";
assert_eq_ignore_span!(
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr()),
Box::new(Expr::Class(ClassExpr {
ident: Some(Ident {
span,
sym: "Foo".into(),
..Default::default()
}),
class: Box::new(Class {
span,
is_abstract: false,
body: vec!(ClassMember::StaticBlock(StaticBlock {
span,
body: BlockStmt {
span,
stmts: Vec::new(),
..Default::default()
}
})),
..Default::default()
})
}))
);
}
#[test]
fn class_static_blocks_in_ts() {
let src = "class Foo { static { 1 + 1 }; }";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
fn class_static_blocks_with_line_breaks_in_ts_01() {
let src = "class Foo {
static
{
1 + 1;
}
}";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
fn class_static_blocks_with_line_breaks_in_ts_02() {
let src = "class Foo {
static
{}
}";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
#[should_panic(expected = "Expected ident")]
fn class_static_blocks_with_await() {
let src = "class Foo{
static {
var await = 'bar';
}
}";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr());
}
#[test]
#[should_panic(expected = "Expected ident")]
fn class_static_blocks_with_await_in_nested_class() {
let src = "class Foo{
static {
function foo() {
class Foo {
static {
var await = 'bar';
}
}
}
}
}";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr());
}
#[test]
fn class_static_blocks_with_await_in_fn() {
let src = "class Foo{
static {
function foo() {
var await = 'bar';
}
}
}";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr());
}
#[test]
#[should_panic(expected = "Modifiers cannot appear here")]
fn class_static_blocks_in_ts_with_invalid_modifier_01() {
let src = "class Foo { abstract static { 1 + 1 }; }";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
#[should_panic(expected = "Modifiers cannot appear here")]
fn class_static_blocks_in_ts_with_invalid_modifier_02() {
let src = "class Foo { static static { 1 + 1 }; }";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
#[should_panic(expected = "Modifiers cannot appear here")]
fn class_static_blocks_in_ts_with_invalid_modifier_03() {
let src = "class Foo { declare static { 1 + 1 }; }";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
#[should_panic(expected = "Modifiers cannot appear here")]
fn class_static_blocks_in_ts_with_invalid_modifier_04() {
let src = "class Foo { private static { 1 + 1 }; }";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_expr()
});
}
#[test]
#[should_panic(expected = "Trailing comma is disallowed inside import(...) arguments")]
fn error_for_trailing_comma_inside_dynamic_import() {
let src = "import('foo',)";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_expr());
}
#[test]
fn no_error_for_trailing_comma_inside_dynamic_import_with_import_assertions() {
let src = "import('foo',)";
test_parser(
src,
Syntax::Es(EsSyntax {
import_attributes: true,
..Default::default()
}),
|p| p.parse_expr(),
);
}
#[test]
fn type_only_star_exports_with_name() {
let src = "export type * as bar from 'mod'";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_module()
});
}
#[test]
fn type_only_star_exports_without_name() {
let src = "export type * from 'mod'";
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_module()
});
}
#[test]
#[should_panic(expected = "A string literal cannot be used as an imported binding.")]
fn error_for_string_literal_is_import_binding() {
let src = "import { \"str\" } from \"mod\"";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
#[should_panic(
expected = "A string literal cannot be used as an exported binding without `from`."
)]
fn error_for_string_literal_is_export_binding() {
let src = "export { 'foo' };";
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_module());
}
#[test]
#[should_panic(expected = "'const' declarations must be initialized")]
fn ts_error_for_const_declaration_not_initialized() {
let src = r#"
"use strict";
const foo;"#;
test_parser(src, Syntax::Typescript(Default::default()), |p| {
p.parse_script()
});
}
#[test]
#[should_panic(expected = "'const' declarations must be initialized")]
fn es_error_for_const_declaration_not_initialized() {
let src = r#"
"use strict";
const foo;"#;
test_parser(src, Syntax::Es(Default::default()), |p| p.parse_script());
}
#[test]
fn issue_5557_expr_follow_class() {
let src = "foo * class {} / bar;";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_5722_class_keyword_in_tpl() {
let src = "console.log(`${toStr({class: fn})}`)";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6301_await_expr_stmt() {
let src = "try { await; } catch { console.log('caught'); }";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6301_await_expr_stmt_1() {
let src = "try { await, await; } catch { console.log('caught'); }";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6301_await_expr_stmt_2() {
let src = "function test() { await; }";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6301_await_expr_stmt_3() {
let src = "function test() { await, await; }";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6301_await_expr_stmt_4() {
let src = "function test() { [await]; }";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6301_await_expr_stmt_5() {
let src = "function test() { (await); }";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6322() {
let src = "for ( ; { } / 1 ; ) ;";
test_parser(src, Default::default(), |p| p.parse_script());
}
#[test]
fn issue_6323() {
let src = "let x = 0 < { } / 0 ;";
test_parser(src, Default::default(), |p| p.parse_script());
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/stmt/module_item.rs | Rust | use super::*;
impl<I: Tokens> Parser<I> {
fn parse_import(&mut self) -> PResult<ModuleItem> {
let start = cur_pos!(self);
if peeked_is!(self, '.') {
let expr = self.parse_expr()?;
eat!(self, ';');
return Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into());
}
if peeked_is!(self, '(') {
let expr = self.parse_expr()?;
eat!(self, ';');
return Ok(ExprStmt {
span: span!(self, start),
expr,
}
.into());
}
// It's now import statement
if !self.ctx().module {
// Switch to module mode
let ctx = Context {
module: true,
strict: true,
..self.ctx()
};
self.set_ctx(ctx);
}
expect!(self, "import");
// Handle import 'mod.js'
let str_start = cur_pos!(self);
if let Ok(&Token::Str { .. }) = cur!(self, false) {
let src = match bump!(self) {
Token::Str { value, raw, .. } => Box::new(Str {
span: span!(self, str_start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
};
let _ = cur!(self, false);
let with = if self.input.syntax().import_attributes()
&& !self.input.had_line_break_before_cur()
&& (eat!(self, "assert") || eat!(self, "with"))
{
match self.parse_object::<Expr>()? {
Expr::Object(v) => Some(Box::new(v)),
_ => unreachable!(),
}
} else {
None
};
expect!(self, ';');
return Ok(ImportDecl {
span: span!(self, start),
src,
specifiers: Vec::new(),
type_only: false,
with,
phase: Default::default(),
}
.into());
}
let mut type_only = false;
let mut phase = ImportPhase::Evaluation;
let mut specifiers = Vec::new();
'import_maybe_ident: {
if is!(self, BindingIdent) {
let mut local = self.parse_imported_default_binding()?;
if self.input.syntax().typescript() && local.sym == "type" {
if is_one_of!(self, '*', '{') {
type_only = true;
break 'import_maybe_ident;
}
if is!(self, BindingIdent) {
if !is!(self, "from") || peeked_is!(self, "from") {
type_only = true;
local = self.parse_imported_default_binding()?;
} else if peeked_is!(self, '=') {
type_only = true;
local = self.parse_ident_name().map(From::from)?;
}
}
}
if self.input.syntax().typescript() && is!(self, '=') {
return self
.parse_ts_import_equals_decl(start, local, false, type_only)
.map(ModuleDecl::from)
.map(ModuleItem::from);
}
if matches!(&*local.sym, "source" | "defer") {
let new_phase = match &*local.sym {
"source" => ImportPhase::Source,
"defer" => ImportPhase::Defer,
_ => unreachable!(),
};
if is_one_of!(self, '*', '{') {
phase = new_phase;
break 'import_maybe_ident;
}
if is!(self, BindingIdent) && !is!(self, "from") || peeked_is!(self, "from") {
phase = new_phase;
local = self.parse_imported_default_binding()?;
}
}
//TODO: Better error reporting
if !is!(self, "from") {
expect!(self, ',');
}
specifiers.push(ImportSpecifier::Default(ImportDefaultSpecifier {
span: local.span,
local,
}));
}
}
{
let import_spec_start = cur_pos!(self);
if eat!(self, '*') {
expect!(self, "as");
let local = self.parse_imported_binding()?;
specifiers.push(ImportSpecifier::Namespace(ImportStarAsSpecifier {
span: span!(self, import_spec_start),
local,
}));
} else if eat!(self, '{') {
while !eof!(self) && !is!(self, '}') {
specifiers.push(self.parse_import_specifier(type_only)?);
if is!(self, '}') {
break;
} else {
expect!(self, ',');
}
}
expect!(self, '}');
}
}
let src = {
expect!(self, "from");
let str_start = cur_pos!(self);
match *cur!(self, true) {
Token::Str { .. } => match bump!(self) {
Token::Str { value, raw, .. } => Box::new(Str {
span: span!(self, str_start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
_ => unexpected!(self, "a string literal"),
}
};
let _ = cur!(self, false);
let with = if self.input.syntax().import_attributes()
&& !self.input.had_line_break_before_cur()
&& (eat!(self, "assert") || eat!(self, "with"))
{
match self.parse_object::<Expr>()? {
Expr::Object(v) => Some(Box::new(v)),
_ => unreachable!(),
}
} else {
None
};
expect!(self, ';');
Ok(ImportDecl {
span: span!(self, start),
specifiers,
src,
type_only,
with,
phase,
}
.into())
}
/// Parse `foo`, `foo2 as bar` in `import { foo, foo2 as bar }`
fn parse_import_specifier(&mut self, type_only: bool) -> PResult<ImportSpecifier> {
let start = cur_pos!(self);
match self.parse_module_export_name()? {
ModuleExportName::Ident(mut orig_name) => {
let mut is_type_only = false;
// Handle:
// `import { type xx } from 'mod'`
// `import { type xx as yy } from 'mod'`
// `import { type as } from 'mod'`
// `import { type as as } from 'mod'`
// `import { type as as as } from 'mod'`
if self.syntax().typescript() && orig_name.sym == "type" && is!(self, IdentName) {
let possibly_orig_name = self.parse_ident_name().map(Ident::from)?;
if possibly_orig_name.sym == "as" {
// `import { type as } from 'mod'`
if !is!(self, IdentName) {
if self.ctx().is_reserved_word(&possibly_orig_name.sym) {
syntax_error!(
self,
possibly_orig_name.span,
SyntaxError::ReservedWordInImport
)
}
if type_only {
self.emit_err(orig_name.span, SyntaxError::TS2206);
}
return Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: span!(self, start),
local: possibly_orig_name,
imported: None,
is_type_only: true,
}));
}
let maybe_as: Ident = self.parse_binding_ident(false)?.into();
if maybe_as.sym == "as" {
if is!(self, IdentName) {
// `import { type as as as } from 'mod'`
// `import { type as as foo } from 'mod'`
let local: Ident = self.parse_binding_ident(false)?.into();
if type_only {
self.emit_err(orig_name.span, SyntaxError::TS2206);
}
return Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: Span::new(start, orig_name.span.hi()),
local,
imported: Some(ModuleExportName::Ident(possibly_orig_name)),
is_type_only: true,
}));
} else {
// `import { type as as } from 'mod'`
return Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: Span::new(start, maybe_as.span.hi()),
local: maybe_as,
imported: Some(ModuleExportName::Ident(orig_name)),
is_type_only: false,
}));
}
} else {
// `import { type as xxx } from 'mod'`
return Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: Span::new(start, orig_name.span.hi()),
local: maybe_as,
imported: Some(ModuleExportName::Ident(orig_name)),
is_type_only: false,
}));
}
} else {
// `import { type xx } from 'mod'`
// `import { type xx as yy } from 'mod'`
if type_only {
self.emit_err(orig_name.span, SyntaxError::TS2206);
}
orig_name = possibly_orig_name;
is_type_only = true;
}
}
if eat!(self, "as") {
let local: Ident = self.parse_binding_ident(false)?.into();
return Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: Span::new(start, local.span.hi()),
local,
imported: Some(ModuleExportName::Ident(orig_name)),
is_type_only,
}));
}
// Handle difference between
//
// 'ImportedBinding'
// 'IdentifierName' as 'ImportedBinding'
if self.ctx().is_reserved_word(&orig_name.sym) {
syntax_error!(self, orig_name.span, SyntaxError::ReservedWordInImport)
}
let local = orig_name;
Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: span!(self, start),
local,
imported: None,
is_type_only,
}))
}
ModuleExportName::Str(orig_str) => {
if eat!(self, "as") {
let local: Ident = self.parse_binding_ident(false)?.into();
Ok(ImportSpecifier::Named(ImportNamedSpecifier {
span: Span::new(start, local.span.hi()),
local,
imported: Some(ModuleExportName::Str(orig_str)),
is_type_only: false,
}))
} else {
syntax_error!(
self,
orig_str.span,
SyntaxError::ImportBindingIsString(orig_str.value)
)
}
}
}
}
fn parse_imported_default_binding(&mut self) -> PResult<Ident> {
self.parse_imported_binding()
}
fn parse_imported_binding(&mut self) -> PResult<Ident> {
let ctx = Context {
in_async: false,
in_generator: false,
..self.ctx()
};
Ok(self.with_ctx(ctx).parse_binding_ident(false)?.into())
}
fn parse_export(&mut self, mut decorators: Vec<Decorator>) -> PResult<ModuleDecl> {
if !self.ctx().module {
// Switch to module mode
let ctx = Context {
module: true,
strict: true,
..self.ctx()
};
self.set_ctx(ctx);
}
let start = cur_pos!(self);
assert_and_bump!(self, "export");
let _ = cur!(self, true);
let after_export_start = cur_pos!(self);
// "export declare" is equivalent to just "export".
let declare = self.input.syntax().typescript() && eat!(self, "declare");
if declare {
// TODO: Remove
if let Some(decl) = self.try_parse_ts_declare(after_export_start, decorators.clone())? {
return Ok(ExportDecl {
span: span!(self, start),
decl,
}
.into());
}
}
if self.input.syntax().typescript() && is!(self, IdentName) {
let sym = match *cur!(self, true) {
Token::Word(ref w) => w.clone().into(),
_ => unreachable!(),
};
// TODO: remove clone
if let Some(decl) = self.try_parse_ts_export_decl(decorators.clone(), sym) {
return Ok(ExportDecl {
span: span!(self, start),
decl,
}
.into());
}
}
if self.input.syntax().typescript() {
if eat!(self, "import") {
let is_type_only = is!(self, "type") && peeked_is!(self, IdentRef);
if is_type_only {
assert_and_bump!(self, "type");
}
let id = self.parse_ident_name()?;
// export import A = B
return self
.parse_ts_import_equals_decl(
start,
id.into(),
/* is_export */ true,
is_type_only,
)
.map(From::from);
}
if eat!(self, '=') {
// `export = x;`
let expr = self.parse_expr()?;
expect!(self, ';');
return Ok(TsExportAssignment {
span: span!(self, start),
expr,
}
.into());
}
if eat!(self, "as") {
// `export as namespace A;`
// See `parseNamespaceExportDeclaration` in TypeScript's own parser
expect!(self, "namespace");
let id = self.parse_ident(false, false)?;
expect!(self, ';');
return Ok(TsNamespaceExportDecl {
span: span!(self, start),
id,
}
.into());
}
}
let ns_export_specifier_start = cur_pos!(self);
let type_only = self.input.syntax().typescript() && eat!(self, "type");
// Some("default") if default is exported from 'src'
let mut export_default = None;
if !type_only && eat!(self, "default") {
if is!(self, '@') {
let start = cur_pos!(self);
let after_decorators = self.parse_decorators(false)?;
if !decorators.is_empty() {
syntax_error!(self, span!(self, start), SyntaxError::TS8038);
}
decorators = after_decorators;
}
if self.input.syntax().typescript() {
if is!(self, "abstract")
&& peeked_is!(self, "class")
&& !self.input.has_linebreak_between_cur_and_peeked()
{
let class_start = cur_pos!(self);
assert_and_bump!(self, "abstract");
let _ = cur!(self, true);
return self
.parse_default_class(start, class_start, decorators, true)
.map(ModuleDecl::ExportDefaultDecl);
}
if is!(self, "abstract") && peeked_is!(self, "interface") {
self.emit_err(self.input.cur_span(), SyntaxError::TS1242);
assert_and_bump!(self, "abstract");
}
if is!(self, "interface") {
let interface_start = cur_pos!(self);
assert_and_bump!(self, "interface");
let decl = self
.parse_ts_interface_decl(interface_start)
.map(DefaultDecl::from)?;
return Ok(ExportDefaultDecl {
span: span!(self, start),
decl,
}
.into());
}
}
if is!(self, "class") {
let class_start = cur_pos!(self);
let decl = self.parse_default_class(start, class_start, decorators, false)?;
return Ok(decl.into());
} else if is!(self, "async")
&& peeked_is!(self, "function")
&& !self.input.has_linebreak_between_cur_and_peeked()
{
let decl = self.parse_default_async_fn(start, decorators)?;
return Ok(decl.into());
} else if is!(self, "function") {
let decl = self.parse_default_fn(start, decorators)?;
return Ok(decl.into());
} else if self.input.syntax().export_default_from()
&& (is!(self, "from")
|| (is!(self, ',') && (peeked_is!(self, '{') || peeked_is!(self, '*'))))
{
export_default = Some(Ident::new_no_ctxt("default".into(), self.input.prev_span()))
} else {
let expr = self.include_in_expr(true).parse_assignment_expr()?;
expect!(self, ';');
return Ok(ExportDefaultExpr {
span: span!(self, start),
expr,
}
.into());
}
}
if is!(self, '@') {
let start = cur_pos!(self);
let after_decorators = self.parse_decorators(false)?;
if !decorators.is_empty() {
syntax_error!(self, span!(self, start), SyntaxError::TS8038);
}
decorators = after_decorators;
}
let decl = if !type_only && is!(self, "class") {
let class_start = cur_pos!(self);
self.parse_class_decl(start, class_start, decorators, false)?
} else if !type_only
&& is!(self, "async")
&& peeked_is!(self, "function")
&& !self.input.has_linebreak_between_cur_and_peeked()
{
self.parse_async_fn_decl(decorators)?
} else if !type_only && is!(self, "function") {
self.parse_fn_decl(decorators)?
} else if !type_only
&& self.input.syntax().typescript()
&& is!(self, "const")
&& peeked_is!(self, "enum")
{
let enum_start = cur_pos!(self);
assert_and_bump!(self, "const");
let _ = cur!(self, true);
assert_and_bump!(self, "enum");
return self
.parse_ts_enum_decl(enum_start, /* is_const */ true)
.map(Decl::from)
.map(|decl| {
ExportDecl {
span: span!(self, start),
decl,
}
.into()
});
} else if !type_only
&& (is!(self, "var")
|| is!(self, "const")
|| (is!(self, "let"))
&& peek!(self)
.map(|t| {
// module code is always in strict mode.
t.kind().follows_keyword_let(true)
})
.unwrap_or(false))
{
self.parse_var_stmt(false).map(Decl::Var)?
} else {
// ```javascript
// export foo, * as bar, { baz } from "mod"; // *
// export * as bar, { baz } from "mod"; // *
// export foo, { baz } from "mod"; // *
// export foo, * as bar from "mod"; // *
// export foo from "mod"; // *
// export * as bar from "mod"; //
// export { baz } from "mod"; //
// export { baz } ; //
// export * from "mod"; //
// ```
// export default
// export foo
let default = match export_default {
Some(default) => Some(default),
None => {
if self.input.syntax().export_default_from() && is!(self, IdentName) {
Some(self.parse_ident(false, false)?)
} else {
None
}
}
};
if default.is_none() && is!(self, '*') && !peeked_is!(self, "as") {
assert_and_bump!(self, '*');
// improve error message for `export * from foo`
let (src, with) = self.parse_from_clause_and_semi()?;
return Ok(ExportAll {
span: span!(self, start),
src,
type_only,
with,
}
.into());
}
let mut specifiers = Vec::new();
let mut has_default = false;
let mut has_ns = false;
if let Some(default) = default {
has_default = true;
specifiers.push(ExportSpecifier::Default(ExportDefaultSpecifier {
exported: default,
}))
}
// export foo, * as bar
// ^
if !specifiers.is_empty() && is!(self, ',') && peeked_is!(self, '*') {
assert_and_bump!(self, ',');
has_ns = true;
}
// export * as bar
// ^
else if specifiers.is_empty() && is!(self, '*') {
has_ns = true;
}
if has_ns {
assert_and_bump!(self, '*');
expect!(self, "as");
let name = self.parse_module_export_name()?;
specifiers.push(ExportSpecifier::Namespace(ExportNamespaceSpecifier {
span: span!(self, ns_export_specifier_start),
name,
}));
}
if has_default || has_ns {
if is!(self, "from") {
let (src, with) = self.parse_from_clause_and_semi()?;
return Ok(NamedExport {
span: span!(self, start),
specifiers,
src: Some(src),
type_only,
with,
}
.into());
} else if !self.input.syntax().export_default_from() {
// emit error
expect!(self, "from");
}
expect!(self, ',');
}
expect!(self, '{');
while !eof!(self) && !is!(self, '}') {
let specifier = self.parse_named_export_specifier(type_only)?;
specifiers.push(ExportSpecifier::Named(specifier));
if is!(self, '}') {
break;
} else {
expect!(self, ',');
}
}
expect!(self, '}');
let opt = if is!(self, "from") {
Some(self.parse_from_clause_and_semi()?)
} else {
for s in &specifiers {
match s {
ExportSpecifier::Default(default) => {
self.emit_err(
default.exported.span,
SyntaxError::ExportExpectFrom(default.exported.sym.clone()),
);
}
ExportSpecifier::Namespace(namespace) => {
let export_name = match &namespace.name {
ModuleExportName::Ident(i) => i.sym.clone(),
ModuleExportName::Str(s) => s.value.clone(),
};
self.emit_err(
namespace.span,
SyntaxError::ExportExpectFrom(export_name),
);
}
ExportSpecifier::Named(named) => match &named.orig {
ModuleExportName::Ident(id) if id.is_reserved() => {
self.emit_err(
id.span,
SyntaxError::ExportExpectFrom(id.sym.clone()),
);
}
ModuleExportName::Str(s) => {
self.emit_err(s.span, SyntaxError::ExportBindingIsString);
}
_ => {}
},
}
}
eat!(self, ';');
None
};
let (src, with) = match opt {
Some(v) => (Some(v.0), v.1),
None => (None, None),
};
return Ok(NamedExport {
span: span!(self, start),
specifiers,
src,
type_only,
with,
}
.into());
};
Ok(ExportDecl {
span: span!(self, start),
decl,
}
.into())
}
fn parse_named_export_specifier(&mut self, type_only: bool) -> PResult<ExportNamedSpecifier> {
let start = cur_pos!(self);
let mut is_type_only = false;
let orig = match self.parse_module_export_name()? {
ModuleExportName::Ident(orig_ident) => {
// Handle:
// `export { type xx }`
// `export { type xx as yy }`
// `export { type as }`
// `export { type as as }`
// `export { type as as as }`
if self.syntax().typescript() && orig_ident.sym == "type" && is!(self, IdentName) {
let possibly_orig = self.parse_ident_name().map(Ident::from)?;
if possibly_orig.sym == "as" {
// `export { type as }`
if !is!(self, IdentName) {
if type_only {
self.emit_err(orig_ident.span, SyntaxError::TS2207);
}
return Ok(ExportNamedSpecifier {
span: span!(self, start),
orig: ModuleExportName::Ident(possibly_orig),
exported: None,
is_type_only: true,
});
}
let maybe_as = self.parse_ident_name().map(Ident::from)?;
if maybe_as.sym == "as" {
if is!(self, IdentName) {
// `export { type as as as }`
// `export { type as as foo }`
let exported = self.parse_ident_name().map(Ident::from)?;
if type_only {
self.emit_err(orig_ident.span, SyntaxError::TS2207);
}
return Ok(ExportNamedSpecifier {
span: Span::new(start, orig_ident.span.hi()),
orig: ModuleExportName::Ident(possibly_orig),
exported: Some(ModuleExportName::Ident(exported)),
is_type_only: true,
});
} else {
// `export { type as as }`
return Ok(ExportNamedSpecifier {
span: Span::new(start, orig_ident.span.hi()),
orig: ModuleExportName::Ident(orig_ident),
exported: Some(ModuleExportName::Ident(maybe_as)),
is_type_only: false,
});
}
} else {
// `export { type as xxx }`
return Ok(ExportNamedSpecifier {
span: Span::new(start, orig_ident.span.hi()),
orig: ModuleExportName::Ident(orig_ident),
exported: Some(ModuleExportName::Ident(maybe_as)),
is_type_only: false,
});
}
} else {
// `export { type xx }`
// `export { type xx as yy }`
if type_only {
self.emit_err(orig_ident.span, SyntaxError::TS2207);
}
is_type_only = true;
ModuleExportName::Ident(possibly_orig)
}
} else {
ModuleExportName::Ident(orig_ident)
}
}
module_export_name => module_export_name,
};
let exported = if eat!(self, "as") {
Some(self.parse_module_export_name()?)
} else {
None
};
Ok(ExportNamedSpecifier {
span: span!(self, start),
orig,
exported,
is_type_only,
})
}
/// Parses `from 'foo.js' with {};` or `from 'foo.js' assert {};`
fn parse_from_clause_and_semi(&mut self) -> PResult<(Box<Str>, Option<Box<ObjectLit>>)> {
expect!(self, "from");
let str_start = cur_pos!(self);
let src = match *cur!(self, true) {
Token::Str { .. } => match bump!(self) {
Token::Str { value, raw, .. } => Box::new(Str {
span: span!(self, str_start),
value,
raw: Some(raw),
}),
_ => unreachable!(),
},
_ => unexpected!(self, "a string literal"),
};
let _ = cur!(self, false);
let with = if self.input.syntax().import_attributes()
&& !self.input.had_line_break_before_cur()
&& (eat!(self, "assert") || eat!(self, "with"))
{
match self.parse_object::<Expr>()? {
Expr::Object(v) => Some(Box::new(v)),
_ => unreachable!(),
}
} else {
None
};
expect!(self, ';');
Ok((src, with))
}
}
impl IsDirective for ModuleItem {
fn as_ref(&self) -> Option<&Stmt> {
match *self {
ModuleItem::Stmt(ref s) => Some(s),
_ => None,
}
}
}
impl<I: Tokens> StmtLikeParser<'_, ModuleItem> for Parser<I> {
fn handle_import_export(
&mut self,
top_level: bool,
decorators: Vec<Decorator>,
) -> PResult<ModuleItem> {
if !top_level {
syntax_error!(self, SyntaxError::NonTopLevelImportExport);
}
let decl = if is!(self, "import") {
self.parse_import()?
} else if is!(self, "export") {
self.parse_export(decorators).map(ModuleItem::from)?
} else {
unreachable!(
"handle_import_export should not be called if current token isn't import nor \
export"
)
};
Ok(decl)
}
}
#[cfg(test)]
mod tests {
use crate::{EsSyntax, Syntax};
#[test]
fn test_legacy_decorator() {
crate::test_parser(
"@foo
export default class Foo {
bar() {
class Baz {}
}
}",
Syntax::Es(EsSyntax {
decorators: true,
decorators_before_export: true,
..Default::default()
}),
|p| p.parse_module(),
);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/tests.rs | Rust | use swc_common::comments::SingleThreadedComments;
use super::*;
use crate::EsSyntax;
fn program(src: &'static str) -> Program {
test_parser(src, Default::default(), |p| p.parse_program())
}
/// Assert that Parser.parse_program returns [Program::Module].
fn module(src: &'static str) -> Module {
program(src).expect_module()
}
/// Assert that Parser.parse_program returns [Program::Script].
fn script(src: &'static str) -> Script {
program(src).expect_script()
}
/// Assert that Parser.parse_program returns [Program::Module] and has errors.
#[track_caller]
fn assert_module_error(src: &'static str) -> Module {
test_parser(src, Default::default(), |p| {
let program = p.parse_program()?;
let errors = p.take_errors();
assert_ne!(errors, Vec::new());
let module = program.expect_module();
Ok(module)
})
}
#[test]
fn parse_program_module_01() {
module("import 'foo';");
module("export const a = 1;");
}
#[test]
fn parse_program_script_01() {
script("let a = 5;");
script("function foo() {}");
script("const a = 00176;");
}
#[test]
fn parse_program_module_02() {
module(
"
function foo() {}
export default foo;
",
);
module(
"
export function foo() {}
export default foo;
",
);
}
#[test]
fn parse_program_module_error_01() {
assert_module_error(
"
const a = 01234;
export default a;
",
);
}
#[test]
fn issue_1813() {
test_parser(
"\\u{cccccccccsccccccQcXt[uc(~).const[uctor().const[uctor())tbr())",
Default::default(),
|p| {
p.parse_program().expect_err("should fail");
Ok(())
},
)
}
#[test]
fn parse_module_export_named_span() {
let m = module("export function foo() {}");
if let ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl { span, .. })) = &m.body[0] {
assert_eq!(span.lo, BytePos(1));
} else {
panic!("expected ExportDecl");
}
}
#[test]
fn parse_module_export_default_fn_span() {
let m = module("export default function foo() {}");
if let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
span, ..
})) = &m.body[0]
{
assert_eq!(span.lo, BytePos(1));
assert_eq!(span.hi, BytePos(33));
} else {
panic!("expected ExportDefaultDecl");
}
}
#[test]
fn parse_module_export_default_async_fn_span() {
let m = module("export default async function foo() {}");
if let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
span, ..
})) = &m.body[0]
{
assert_eq!(span.lo, BytePos(1));
assert_eq!(span.hi, BytePos(39));
} else {
panic!("expected ExportDefaultDecl");
}
}
#[test]
fn parse_module_export_default_class_span() {
let m = module("export default class Foo {}");
if let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
span, ..
})) = &m.body[0]
{
assert_eq!(span.lo, BytePos(1));
assert_eq!(span.hi, BytePos(28));
} else {
panic!("expected ExportDefaultDecl");
}
}
#[test]
fn issue_1878() {
// file with only comments should have the comments
// in the leading map instead of the trailing
{
let c = SingleThreadedComments::default();
let s = "
// test
";
let _ = super::test_parser_comment(&c, s, Syntax::Typescript(Default::default()), |p| {
p.parse_typescript_module()
});
let (leading, trailing) = c.take_all();
assert!(trailing.borrow().is_empty());
assert_eq!(leading.borrow().len(), 1);
assert!(leading.borrow().get(&BytePos(1)).is_some());
}
// file with shebang and comments should still work with the comments trailing
// the shebang
{
let c = SingleThreadedComments::default();
let s = "#!/foo/bar
// test
";
let _ = super::test_parser_comment(&c, s, Syntax::Typescript(Default::default()), |p| {
p.parse_typescript_module()
});
let (leading, trailing) = c.take_all();
assert!(leading.borrow().is_empty());
assert_eq!(trailing.borrow().len(), 1);
assert!(trailing.borrow().get(&BytePos(11)).is_some());
}
}
#[test]
fn issue_2264_1() {
let c = SingleThreadedComments::default();
let s = "
const t = <Switch>
// 1
/* 2 */
</Switch>
";
let _ = super::test_parser_comment(
&c,
s,
Syntax::Typescript(TsSyntax {
tsx: true,
..Default::default()
}),
|p| p.parse_typescript_module(),
);
let (_leading, trailing) = c.take_all();
// assert!(leading.borrow().is_empty());
assert!(trailing.borrow().is_empty());
}
#[test]
fn issue_2264_2() {
let c = SingleThreadedComments::default();
let s = "
const t = <Switch>
// 1
/* 2 */
</Switch>
";
let _ = super::test_parser_comment(
&c,
s,
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
|p| p.parse_module(),
);
let (leading, trailing) = c.take_all();
assert!(leading.borrow().is_empty());
assert!(trailing.borrow().is_empty());
}
#[test]
fn issue_2264_3() {
let c = SingleThreadedComments::default();
let s = "const foo = <h1>/* no */{/* 1 */ bar /* 2 */}/* no */</h1>;";
let _ = super::test_parser_comment(
&c,
s,
Syntax::Typescript(TsSyntax {
tsx: true,
..Default::default()
}),
|p| p.parse_typescript_module(),
);
let (leading, trailing) = c.take_all();
assert!(leading.borrow().is_empty());
assert_eq!(trailing.borrow().len(), 2);
assert_eq!(trailing.borrow().get(&BytePos(26)).unwrap().len(), 1);
assert_eq!(trailing.borrow().get(&BytePos(37)).unwrap().len(), 1);
}
#[test]
fn issue_2339_1() {
let c = SingleThreadedComments::default();
let s = "
const t = <T>() => {
// 1
/* 2 */
test;
};
";
let _ = super::test_parser_comment(
&c,
s,
Syntax::Typescript(TsSyntax {
tsx: true,
..Default::default()
}),
|p| p.parse_typescript_module(),
);
let (leading, trailing) = c.take_all();
assert_eq!(leading.borrow().len(), 1);
assert_eq!(leading.borrow().get(&BytePos(80)).unwrap().len(), 2);
assert!(trailing.borrow().is_empty());
}
#[test]
fn issue_2853_1() {
test_parser("const a = \"\\0a\";", Default::default(), |p| {
let program = p.parse_program()?;
let errors = p.take_errors();
assert_eq!(errors, Vec::new());
assert_eq!(errors, Vec::new());
Ok(program)
});
}
#[test]
fn issue_2853_2() {
test_parser("const a = \"\u{0000}a\";", Default::default(), |p| {
let program = p.parse_program()?;
let errors = p.take_errors();
assert_eq!(errors, Vec::new());
Ok(program)
});
}
#[test]
fn illegal_language_mode_directive1() {
test_parser(
r#"function f(a = 0) { "use strict"; }"#,
Default::default(),
|p| {
let program = p.parse_program()?;
let errors = p.take_errors();
assert_eq!(
errors,
vec![Error::new(
Span {
lo: BytePos(21),
hi: BytePos(34),
},
crate::parser::SyntaxError::IllegalLanguageModeDirective
)]
);
Ok(program)
},
);
}
#[test]
fn illegal_language_mode_directive2() {
test_parser(
r#"let f = (a = 0) => { "use strict"; }"#,
Default::default(),
|p| {
let program = p.parse_program()?;
let errors = p.take_errors();
assert_eq!(
errors,
vec![Error::new(
Span {
lo: BytePos(22),
hi: BytePos(35),
},
crate::parser::SyntaxError::IllegalLanguageModeDirective
)]
);
Ok(program)
},
);
}
#[test]
fn parse_non_strict_for_loop() {
script("for (var v1 = 1 in v3) {}");
}
#[test]
fn parse_program_take_script_module_errors() {
test_parser(r#"077;"#, Default::default(), |p| {
let program = p.parse_program()?;
assert_eq!(p.take_errors(), vec![]);
// will contain the script's potential module errors
assert_eq!(
p.take_script_module_errors(),
vec![Error::new(
Span {
lo: BytePos(1),
hi: BytePos(4),
},
crate::parser::SyntaxError::LegacyOctal
)]
);
Ok(program)
});
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/typescript.rs | Rust | use std::fmt::Write;
use either::Either;
use swc_atoms::atom;
use swc_common::Spanned;
use super::*;
use crate::{lexer::TokenContexts, parser::class_and_fn::IsSimpleParameterList, token::Keyword};
impl<I: Tokens> Parser<I> {
/// `tsNextTokenCanFollowModifier`
fn ts_next_token_can_follow_modifier(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
// Note: TypeScript's implementation is much more complicated because
// more things are considered modifiers there.
// This implementation only handles modifiers not handled by @babel/parser
// itself. And "static". TODO: Would be nice to avoid lookahead. Want a
// hasLineBreakUpNext() method...
bump!(self);
Ok(!self.input.had_line_break_before_cur()
&& is_one_of!(self, '[', '{', '*', "...", '#', IdentName, Str, Num, BigInt))
}
/// Parses a modifier matching one the given modifier names.
///
/// `tsParseModifier`
pub(super) fn parse_ts_modifier(
&mut self,
allowed_modifiers: &[&'static str],
stop_on_start_of_class_static_blocks: bool,
) -> PResult<Option<&'static str>> {
if !self.input.syntax().typescript() {
return Ok(None);
}
let pos = {
let modifier = match *cur!(self, true) {
Token::Word(ref w @ Word::Ident(..))
| Token::Word(ref w @ Word::Keyword(Keyword::In | Keyword::Const)) => w.cow(),
_ => return Ok(None),
};
allowed_modifiers.iter().position(|s| **s == **modifier)
};
if let Some(pos) = pos {
if stop_on_start_of_class_static_blocks && is!(self, "static") && peeked_is!(self, '{')
{
return Ok(None);
}
if self.try_parse_ts_bool(|p| p.ts_next_token_can_follow_modifier().map(Some))? {
return Ok(Some(allowed_modifiers[pos]));
}
}
Ok(None)
}
/// `tsIsListTerminator`
fn is_ts_list_terminator(&mut self, kind: ParsingContext) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
Ok(match kind {
ParsingContext::EnumMembers | ParsingContext::TypeMembers => is!(self, '}'),
ParsingContext::HeritageClauseElement { .. } => {
is!(self, '{') || is!(self, "implements") || is!(self, "extends")
}
ParsingContext::TupleElementTypes => is!(self, ']'),
ParsingContext::TypeParametersOrArguments => is!(self, '>'),
})
}
/// `tsParseList`
fn parse_ts_list<T, F>(&mut self, kind: ParsingContext, mut parse_element: F) -> PResult<Vec<T>>
where
F: FnMut(&mut Self) -> PResult<T>,
{
debug_assert!(self.input.syntax().typescript());
let mut buf = Vec::new();
while !self.is_ts_list_terminator(kind)? {
// Skipping "parseListElement" from the TS source since that's just for error
// handling.
buf.push(parse_element(self)?);
}
Ok(buf)
}
/// `tsParseDelimitedList`
fn parse_ts_delimited_list<T, F>(
&mut self,
kind: ParsingContext,
mut parse_element: F,
) -> PResult<Vec<T>>
where
F: FnMut(&mut Self) -> PResult<T>,
{
self.parse_ts_delimited_list_inner(kind, |p| {
let start = p.input.cur_pos();
Ok((start, parse_element(p)?))
})
}
/// `tsParseDelimitedList`
fn parse_ts_delimited_list_inner<T, F>(
&mut self,
kind: ParsingContext,
mut parse_element: F,
) -> PResult<Vec<T>>
where
F: FnMut(&mut Self) -> PResult<(BytePos, T)>,
{
debug_assert!(self.input.syntax().typescript());
let mut buf = Vec::new();
loop {
trace_cur!(self, parse_ts_delimited_list_inner__element);
if self.is_ts_list_terminator(kind)? {
break;
}
let (_, element) = parse_element(self)?;
buf.push(element);
if eat!(self, ',') {
continue;
}
if self.is_ts_list_terminator(kind)? {
break;
}
if kind == ParsingContext::EnumMembers {
const TOKEN: &Token = &Token::Comma;
let cur = match cur!(self, false).ok() {
Some(tok) => format!("{:?}", tok),
None => "EOF".to_string(),
};
self.emit_err(self.input.cur_span(), SyntaxError::Expected(TOKEN, cur));
continue;
}
// This will fail with an error about a missing comma
expect!(self, ',');
}
Ok(buf)
}
fn parse_ts_bracketed_list<T, F>(
&mut self,
kind: ParsingContext,
parse_element: F,
bracket: bool,
skip_first_token: bool,
) -> PResult<Vec<T>>
where
F: FnMut(&mut Self) -> PResult<T>,
{
debug_assert!(self.input.syntax().typescript());
if !skip_first_token {
if bracket {
expect!(self, '[');
} else {
expect!(self, '<');
}
}
let result = self.parse_ts_delimited_list(kind, parse_element)?;
if bracket {
expect!(self, ']');
} else {
expect!(self, '>');
}
Ok(result)
}
/// `tsParseEntityName`
fn parse_ts_entity_name(&mut self, allow_reserved_words: bool) -> PResult<TsEntityName> {
debug_assert!(self.input.syntax().typescript());
trace_cur!(self, parse_ts_entity_name);
let start = cur_pos!(self);
let init = self.parse_ident_name()?;
if &*init.sym == "void" {
let dot_start = cur_pos!(self);
let dot_span = span!(self, dot_start);
self.emit_err(dot_span, SyntaxError::TS1005)
}
let mut entity = TsEntityName::Ident(init.into());
while eat!(self, '.') {
let dot_start = cur_pos!(self);
if !is!(self, '#') && !is!(self, IdentName) {
self.emit_err(Span::new(dot_start, dot_start), SyntaxError::TS1003);
return Ok(entity);
}
let left = entity;
let right = if allow_reserved_words {
self.parse_ident_name()?
} else {
self.parse_ident(false, false)?.into()
};
let span = span!(self, start);
entity = TsEntityName::TsQualifiedName(Box::new(TsQualifiedName { span, left, right }));
}
Ok(entity)
}
/// `tsParseTypeReference`
fn parse_ts_type_ref(&mut self) -> PResult<TsTypeRef> {
trace_cur!(self, parse_ts_type_ref);
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let has_modifier = self.eat_any_ts_modifier()?;
let type_name = self.parse_ts_entity_name(/* allow_reserved_words */ true)?;
trace_cur!(self, parse_ts_type_ref__type_args);
let type_params = if !self.input.had_line_break_before_cur() && is!(self, '<') {
let ctx = Context {
should_not_lex_lt_or_gt_as_type: false,
..self.ctx()
};
Some(self.with_ctx(ctx).parse_ts_type_args()?)
} else {
None
};
if has_modifier {
self.emit_err(span!(self, start), SyntaxError::TS2369);
}
Ok(TsTypeRef {
span: span!(self, start),
type_name,
type_params,
})
}
/// `tsParseThisTypePredicate`
fn parse_ts_this_type_predicate(
&mut self,
start: BytePos,
has_asserts_keyword: bool,
lhs: TsThisType,
) -> PResult<TsTypePredicate> {
debug_assert!(self.input.syntax().typescript());
let param_name = TsThisTypeOrIdent::TsThisType(lhs);
let type_ann = if eat!(self, "is") {
let cur_pos = cur_pos!(self);
Some(self.parse_ts_type_ann(
// eat_colon
false, cur_pos,
)?)
} else {
None
};
Ok(TsTypePredicate {
span: span!(self, start),
asserts: has_asserts_keyword,
param_name,
type_ann,
})
}
/// `tsParseThisTypeNode`
fn parse_ts_this_type_node(&mut self) -> PResult<TsThisType> {
debug_assert!(self.input.syntax().typescript());
expect!(self, "this");
Ok(TsThisType {
span: self.input.prev_span(),
})
}
/// `tsParseImportType`
fn parse_ts_import_type(&mut self) -> PResult<TsImportType> {
let start = cur_pos!(self);
assert_and_bump!(self, "import");
expect!(self, '(');
let _ = cur!(self, false);
let arg_span = self.input.cur_span();
let arg = match cur!(self, true) {
Token::Str { .. } => match bump!(self) {
Token::Str { value, raw } => Str {
span: arg_span,
value,
raw: Some(raw),
},
_ => unreachable!(),
},
_ => {
bump!(self);
self.emit_err(arg_span, SyntaxError::TS1141);
Str {
span: arg_span,
value: "".into(),
raw: Some("\"\"".into()),
}
}
};
// the "assert" keyword is deprecated and this syntax is niche, so
// don't support it
let attributes =
if eat!(self, ',') && self.input.syntax().import_attributes() && is!(self, '{') {
Some(self.parse_ts_call_options()?)
} else {
None
};
expect!(self, ')');
let qualifier = if eat!(self, '.') {
self.parse_ts_entity_name(false).map(Some)?
} else {
None
};
let type_args = if is!(self, '<') {
self.with_ctx(Context {
should_not_lex_lt_or_gt_as_type: false,
..self.ctx()
})
.parse_ts_type_args()
.map(Some)?
} else {
None
};
Ok(TsImportType {
span: span!(self, start),
arg,
qualifier,
type_args,
attributes,
})
}
fn parse_ts_call_options(&mut self) -> PResult<TsImportCallOptions> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
assert_and_bump!(self, '{');
expect!(self, "with");
expect!(self, ':');
let value = match self.parse_object::<Expr>()? {
Expr::Object(v) => v,
_ => unreachable!(),
};
eat!(self, ',');
expect!(self, '}');
Ok(TsImportCallOptions {
span: span!(self, start),
with: Box::new(value),
})
}
/// `tsParseTypeQuery`
fn parse_ts_type_query(&mut self) -> PResult<TsTypeQuery> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
expect!(self, "typeof");
let expr_name = if is!(self, "import") {
self.parse_ts_import_type().map(From::from)?
} else {
self.parse_ts_entity_name(
// allow_reserved_word
true,
)
.map(From::from)?
};
let type_args = if !self.input.had_line_break_before_cur() && is!(self, '<') {
let ctx = Context {
should_not_lex_lt_or_gt_as_type: false,
..self.ctx()
};
Some(self.with_ctx(ctx).parse_ts_type_args()?)
} else {
None
};
Ok(TsTypeQuery {
span: span!(self, start),
expr_name,
type_args,
})
}
/// `tsParseTypeParameter`
fn parse_ts_type_param(
&mut self,
permit_in_out: bool,
permit_const: bool,
) -> PResult<TsTypeParam> {
debug_assert!(self.input.syntax().typescript());
let mut is_in = false;
let mut is_out = false;
let mut is_const = false;
let start = cur_pos!(self);
while let Some(modifer) = self.parse_ts_modifier(
&[
"public",
"private",
"protected",
"readonly",
"abstract",
"const",
"override",
"in",
"out",
],
false,
)? {
match modifer {
"const" => {
is_const = true;
if !permit_const {
self.emit_err(self.input.prev_span(), SyntaxError::TS1277("const".into()));
}
}
"in" => {
if !permit_in_out {
self.emit_err(self.input.prev_span(), SyntaxError::TS1274("in".into()));
} else if is_in {
self.emit_err(self.input.prev_span(), SyntaxError::TS1030("in".into()));
} else if is_out {
self.emit_err(
self.input.prev_span(),
SyntaxError::TS1029("in".into(), "out".into()),
);
}
is_in = true;
}
"out" => {
if !permit_in_out {
self.emit_err(self.input.prev_span(), SyntaxError::TS1274("out".into()));
} else if is_out {
self.emit_err(self.input.prev_span(), SyntaxError::TS1030("out".into()));
}
is_out = true;
}
other => self.emit_err(self.input.prev_span(), SyntaxError::TS1273(other.into())),
};
}
let name = self.in_type().parse_ident_name()?.into();
let constraint = self.eat_then_parse_ts_type(&tok!("extends"))?;
let default = self.eat_then_parse_ts_type(&tok!('='))?;
Ok(TsTypeParam {
span: span!(self, start),
name,
is_in,
is_out,
is_const,
constraint,
default,
})
}
/// `tsParseTypeParameter`
pub(super) fn parse_ts_type_params(
&mut self,
permit_in_out: bool,
permit_const: bool,
) -> PResult<Box<TsTypeParamDecl>> {
self.in_type().parse_with(|p| {
p.ts_in_no_context(|p| {
let start = cur_pos!(p);
if !is!(p, '<') && !is!(p, JSXTagStart) {
unexpected!(p, "< (jsx tag start)")
}
bump!(p); // '<'
let params = p.parse_ts_bracketed_list(
ParsingContext::TypeParametersOrArguments,
|p| p.parse_ts_type_param(permit_in_out, permit_const), // bracket
false,
// skip_first_token
true,
)?;
Ok(Box::new(TsTypeParamDecl {
span: span!(p, start),
params,
}))
})
})
}
/// `tsParseTypeOrTypePredicateAnnotation`
pub(super) fn parse_ts_type_or_type_predicate_ann(
&mut self,
return_token: &'static Token,
) -> PResult<Box<TsTypeAnn>> {
debug_assert!(self.input.syntax().typescript());
self.in_type().parse_with(|p| {
let return_token_start = cur_pos!(p);
if !p.input.eat(return_token) {
let cur = format!("{:?}", cur!(p, false).ok());
let span = p.input.cur_span();
syntax_error!(p, span, SyntaxError::Expected(return_token, cur))
}
let type_pred_start = cur_pos!(p);
let has_type_pred_asserts = is!(p, "asserts") && peeked_is!(p, IdentRef);
if has_type_pred_asserts {
assert_and_bump!(p, "asserts");
cur!(p, false)?;
}
let has_type_pred_is = is!(p, IdentRef)
&& peeked_is!(p, "is")
&& !p.input.has_linebreak_between_cur_and_peeked();
let is_type_predicate = has_type_pred_asserts || has_type_pred_is;
if !is_type_predicate {
return p.parse_ts_type_ann(
// eat_colon
false,
return_token_start,
);
}
let type_pred_var = p.parse_ident_name()?;
let type_ann = if has_type_pred_is {
assert_and_bump!(p, "is");
let pos = cur_pos!(p);
Some(p.parse_ts_type_ann(
// eat_colon
false, pos,
)?)
} else {
None
};
let node = Box::new(TsType::TsTypePredicate(TsTypePredicate {
span: span!(p, type_pred_start),
asserts: has_type_pred_asserts,
param_name: TsThisTypeOrIdent::Ident(type_pred_var.into()),
type_ann,
}));
Ok(Box::new(TsTypeAnn {
span: span!(p, return_token_start),
type_ann: node,
}))
})
}
/// `tsTryParse`
fn try_parse_ts_bool<F>(&mut self, op: F) -> PResult<bool>
where
F: FnOnce(&mut Self) -> PResult<Option<bool>>,
{
if !self.input.syntax().typescript() {
return Ok(false);
}
let prev_ignore_error = self.input.get_ctx().ignore_error;
let mut cloned = self.clone();
let ctx = Context {
ignore_error: true,
..self.input.get_ctx()
};
cloned.set_ctx(ctx);
let res = op(&mut cloned);
match res {
Ok(Some(res)) if res => {
*self = cloned;
let ctx = Context {
ignore_error: prev_ignore_error,
..self.input.get_ctx()
};
self.input.set_ctx(ctx);
Ok(res)
}
Err(..) => Ok(false),
_ => Ok(false),
}
}
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn try_parse_ts_type_args(&mut self) -> Option<Box<TsTypeParamInstantiation>> {
trace_cur!(self, try_parse_ts_type_args);
debug_assert!(self.input.syntax().typescript());
self.try_parse_ts(|p| {
let type_args = p.parse_ts_type_args()?;
if is_one_of!(
p, '<', // invalid syntax
'>', '=', ">>", ">=", '+', '-', // becomes relational expression
/* these should be type arguments in function call or template,
* not instantiation expression */
'(', '`'
) {
Ok(None)
} else if p.input.had_line_break_before_cur()
|| matches!(cur!(p, false), Ok(Token::BinOp(..)))
|| !p.is_start_of_expr()?
{
Ok(Some(type_args))
} else {
Ok(None)
}
})
}
/// `tsTryParse`
pub(super) fn try_parse_ts<T, F>(&mut self, op: F) -> Option<T>
where
F: FnOnce(&mut Self) -> PResult<Option<T>>,
{
if !self.input.syntax().typescript() {
return None;
}
let _tracing = debug_tracing!(self, "try_parse_ts");
trace_cur!(self, try_parse_ts);
let prev_ignore_error = self.input.get_ctx().ignore_error;
let mut cloned = self.clone();
let ctx = Context {
ignore_error: true,
..self.input.get_ctx()
};
cloned.set_ctx(ctx);
let res = op(&mut cloned);
match res {
Ok(Some(res)) => {
*self = cloned;
trace_cur!(self, try_parse_ts__success_value);
let ctx = Context {
ignore_error: prev_ignore_error,
..self.input.get_ctx()
};
self.input.set_ctx(ctx);
Some(res)
}
Ok(None) => {
trace_cur!(self, try_parse_ts__success_no_value);
None
}
Err(..) => {
trace_cur!(self, try_parse_ts__fail);
None
}
}
}
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn parse_ts_type_ann(
&mut self,
eat_colon: bool,
start: BytePos,
) -> PResult<Box<TsTypeAnn>> {
trace_cur!(self, parse_ts_type_ann);
debug_assert!(self.input.syntax().typescript());
self.in_type().parse_with(|p| {
if eat_colon {
assert_and_bump!(p, ':');
}
trace_cur!(p, parse_ts_type_ann__after_colon);
let type_ann = p.parse_ts_type()?;
Ok(Box::new(TsTypeAnn {
span: span!(p, start),
type_ann,
}))
})
}
/// `tsEatThenParseType`
fn eat_then_parse_ts_type(
&mut self,
token_to_eat: &'static Token,
) -> PResult<Option<Box<TsType>>> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
self.in_type().parse_with(|p| {
if !p.input.eat(token_to_eat) {
return Ok(None);
}
p.parse_ts_type().map(Some)
})
}
/// `tsExpectThenParseType`
fn expect_then_parse_ts_type(
&mut self,
token: &'static Token,
token_str: &'static str,
) -> PResult<Box<TsType>> {
debug_assert!(self.input.syntax().typescript());
self.in_type().parse_with(|p| {
if !p.input.eat(token) {
let got = format!("{:?}", cur!(p, false).ok());
syntax_error!(
p,
p.input.cur_span(),
SyntaxError::Unexpected {
got,
expected: token_str
}
);
}
p.parse_ts_type()
})
}
/// `tsNextThenParseType`
pub(super) fn next_then_parse_ts_type(&mut self) -> PResult<Box<TsType>> {
debug_assert!(self.input.syntax().typescript());
let result = self.in_type().parse_with(|p| {
bump!(p);
p.parse_ts_type()
});
if !self.ctx().in_type && is_one_of!(self, '>', '<') {
self.input.merge_lt_gt();
}
result
}
/// `tsParseEnumMember`
fn parse_ts_enum_member(&mut self) -> PResult<TsEnumMember> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
// Computed property names are grammar errors in an enum, so accept just string
// literal or identifier.
let id = match *cur!(self, true) {
Token::Str { .. } => self.parse_lit().map(|lit| match lit {
Lit::Str(s) => TsEnumMemberId::Str(s),
_ => unreachable!(),
})?,
Token::Num { value, ref raw } => {
let mut new_raw = String::new();
new_raw.push('"');
new_raw.push_str(raw);
new_raw.push('"');
bump!(self);
let span = span!(self, start);
// Recover from error
self.emit_err(span, SyntaxError::TS2452);
TsEnumMemberId::Str(Str {
span,
value: value.to_string().into(),
raw: Some(new_raw.into()),
})
}
Token::LBracket => {
assert_and_bump!(self, '[');
let _ = self.parse_expr()?;
self.emit_err(span!(self, start), SyntaxError::TS1164);
expect!(self, ']');
TsEnumMemberId::Ident(Ident::new_no_ctxt(atom!(""), span!(self, start)))
}
_ => self
.parse_ident_name()
.map(Ident::from)
.map(TsEnumMemberId::from)?,
};
let init = if eat!(self, '=') {
Some(self.parse_assignment_expr()?)
} else if is!(self, ',') || is!(self, '}') {
None
} else {
let start = cur_pos!(self);
bump!(self);
store!(self, ',');
self.emit_err(Span::new(start, start), SyntaxError::TS1005);
None
};
Ok(TsEnumMember {
span: span!(self, start),
id,
init,
})
}
/// `tsParseEnumDeclaration`
pub(super) fn parse_ts_enum_decl(
&mut self,
start: BytePos,
is_const: bool,
) -> PResult<Box<TsEnumDecl>> {
debug_assert!(self.input.syntax().typescript());
let id = self.parse_ident_name()?;
expect!(self, '{');
let members = self
.parse_ts_delimited_list(ParsingContext::EnumMembers, |p| p.parse_ts_enum_member())?;
expect!(self, '}');
Ok(Box::new(TsEnumDecl {
span: span!(self, start),
declare: false,
is_const,
id: id.into(),
members,
}))
}
/// `tsParseModuleBlock`
fn parse_ts_module_block(&mut self) -> PResult<TsModuleBlock> {
trace_cur!(self, parse_ts_module_block);
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
expect!(self, '{');
// Inside of a module block is considered "top-level", meaning it can have
// imports and exports.
let body = self.parse_block_body(
/* directives */ false,
/* topLevel */ true,
/* end */ Some(&tok!('}')),
)?;
Ok(TsModuleBlock {
span: span!(self, start),
body,
})
}
/// `tsParseModuleOrNamespaceDeclaration`
fn parse_ts_module_or_ns_decl(
&mut self,
start: BytePos,
namespace: bool,
) -> PResult<Box<TsModuleDecl>> {
debug_assert!(self.input.syntax().typescript());
let id = self.parse_ident_name()?;
let body: TsNamespaceBody = if eat!(self, '.') {
let inner_start = cur_pos!(self);
let inner = self.parse_ts_module_or_ns_decl(inner_start, namespace)?;
let inner = TsNamespaceDecl {
span: inner.span,
id: match inner.id {
TsModuleName::Ident(i) => i,
_ => unreachable!(),
},
body: Box::new(inner.body.unwrap()),
declare: inner.declare,
global: inner.global,
};
inner.into()
} else {
self.parse_ts_module_block().map(From::from)?
};
Ok(Box::new(TsModuleDecl {
span: span!(self, start),
declare: false,
id: TsModuleName::Ident(id.into()),
body: Some(body),
global: false,
namespace,
}))
}
/// `tsParseAmbientExternalModuleDeclaration`
fn parse_ts_ambient_external_module_decl(
&mut self,
start: BytePos,
) -> PResult<Box<TsModuleDecl>> {
debug_assert!(self.input.syntax().typescript());
let (global, id) = if is!(self, "global") {
let id = self.parse_ident_name()?;
(true, TsModuleName::Ident(id.into()))
} else if matches!(*cur!(self, true), Token::Str { .. }) {
let id = self.parse_lit().map(|lit| match lit {
Lit::Str(s) => TsModuleName::Str(s),
_ => unreachable!(),
})?;
(false, id)
} else {
unexpected!(self, "global or a string literal");
};
let body = if is!(self, '{') {
Some(self.parse_ts_module_block().map(TsNamespaceBody::from)?)
} else {
expect!(self, ';');
None
};
Ok(Box::new(TsModuleDecl {
span: span!(self, start),
declare: false,
id,
global,
body,
namespace: false,
}))
}
pub fn parse_type(&mut self) -> PResult<Box<TsType>> {
debug_assert!(self.input.syntax().typescript());
self.in_type().parse_ts_type()
}
/// Be sure to be in a type context before calling self.
///
/// `tsParseType`
pub(super) fn parse_ts_type(&mut self) -> PResult<Box<TsType>> {
trace_cur!(self, parse_ts_type);
debug_assert!(self.input.syntax().typescript());
// Need to set `state.inType` so that we don't parse JSX in a type context.
debug_assert!(self.ctx().in_type);
let start = cur_pos!(self);
self.with_ctx(Context {
disallow_conditional_types: false,
..self.ctx()
})
.parse_with(|p| {
let ty = p.parse_ts_non_conditional_type()?;
if p.input.had_line_break_before_cur() || !eat!(p, "extends") {
return Ok(ty);
}
let check_type = ty;
let extends_type = {
p.with_ctx(Context {
disallow_conditional_types: true,
..p.ctx()
})
.parse_ts_non_conditional_type()?
};
expect!(p, '?');
let true_type = p.parse_ts_type()?;
expect!(p, ':');
let false_type = p.parse_ts_type()?;
Ok(Box::new(TsType::TsConditionalType(TsConditionalType {
span: span!(p, start),
check_type,
extends_type,
true_type,
false_type,
})))
})
}
/// `tsParseNonConditionalType`
fn parse_ts_non_conditional_type(&mut self) -> PResult<Box<TsType>> {
trace_cur!(self, parse_ts_non_conditional_type);
debug_assert!(self.input.syntax().typescript());
if self.is_ts_start_of_fn_type()? {
return self
.parse_ts_fn_or_constructor_type(true)
.map(TsType::from)
.map(Box::new);
}
if (is!(self, "abstract") && peeked_is!(self, "new")) || is!(self, "new") {
// As in `new () => Date`
return self
.parse_ts_fn_or_constructor_type(false)
.map(TsType::from)
.map(Box::new);
}
self.parse_ts_union_type_or_higher()
}
fn is_ts_start_of_fn_type(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
if is!(self, '<') {
return Ok(true);
}
Ok(is!(self, '(') && self.ts_look_ahead(|p| p.is_ts_unambiguously_start_of_fn_type())?)
}
/// `tsParseTypeAssertion`
pub(super) fn parse_ts_type_assertion(&mut self, start: BytePos) -> PResult<TsTypeAssertion> {
debug_assert!(self.input.syntax().typescript());
if self.input.syntax().disallow_ambiguous_jsx_like() {
self.emit_err(span!(self, start), SyntaxError::ReservedTypeAssertion);
}
// Not actually necessary to set state.inType because we never reach here if JSX
// plugin is enabled, but need `tsInType` to satisfy the assertion in
// `tsParseType`.
let type_ann = self.in_type().parse_with(|p| p.parse_ts_type())?;
expect!(self, '>');
let expr = self.parse_unary_expr()?;
Ok(TsTypeAssertion {
span: span!(self, start),
type_ann,
expr,
})
}
/// `tsParseHeritageClause`
pub(super) fn parse_ts_heritage_clause(&mut self) -> PResult<Vec<TsExprWithTypeArgs>> {
debug_assert!(self.input.syntax().typescript());
self.parse_ts_delimited_list(ParsingContext::HeritageClauseElement, |p| {
p.parse_ts_heritage_clause_element()
})
}
fn parse_ts_heritage_clause_element(&mut self) -> PResult<TsExprWithTypeArgs> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
// Note: TS uses parseLeftHandSideExpressionOrHigher,
// then has grammar errors later if it's not an EntityName.
let ident = self.parse_ident_name()?.into();
let expr = self.parse_subscripts(Callee::Expr(ident), true, true)?;
if !matches!(
&*expr,
Expr::Ident(..) | Expr::Member(..) | Expr::TsInstantiation(..)
) {
self.emit_err(span!(self, start), SyntaxError::TS2499);
}
match *expr {
Expr::TsInstantiation(v) => Ok(TsExprWithTypeArgs {
span: v.span,
expr: v.expr,
type_args: Some(v.type_args),
}),
_ => {
let type_args = if is!(self, '<') {
Some(self.parse_ts_type_args()?)
} else {
None
};
Ok(TsExprWithTypeArgs {
span: span!(self, start),
expr,
type_args,
})
}
}
}
/// `tsParseInterfaceDeclaration`
pub(super) fn parse_ts_interface_decl(
&mut self,
start: BytePos,
) -> PResult<Box<TsInterfaceDecl>> {
debug_assert!(self.input.syntax().typescript());
let id = self.parse_ident_name()?;
match &*id.sym {
"string" | "null" | "number" | "object" | "any" | "unknown" | "boolean" | "bigint"
| "symbol" | "void" | "never" | "intrinsic" => {
self.emit_err(id.span, SyntaxError::TS2427);
}
_ => {}
}
let type_params = self.try_parse_ts_type_params(true, false)?;
let extends = if eat!(self, "extends") {
self.parse_ts_heritage_clause()?
} else {
Vec::new()
};
// Recover from
//
// interface I extends A extends B {}
if is!(self, "extends") {
self.emit_err(self.input.cur_span(), SyntaxError::TS1172);
while !eof!(self) && !is!(self, '{') {
bump!(self);
}
}
let body_start = cur_pos!(self);
let body = self
.in_type()
.parse_with(|p| p.parse_ts_object_type_members())?;
let body = TsInterfaceBody {
span: span!(self, body_start),
body,
};
Ok(Box::new(TsInterfaceDecl {
span: span!(self, start),
declare: false,
id: id.into(),
type_params,
extends,
body,
}))
}
/// `tsParseTypeAliasDeclaration`
pub(super) fn parse_ts_type_alias_decl(
&mut self,
start: BytePos,
) -> PResult<Box<TsTypeAliasDecl>> {
debug_assert!(self.input.syntax().typescript());
let id = self.parse_ident_name()?;
let type_params = self.try_parse_ts_type_params(true, false)?;
let type_ann = self.expect_then_parse_ts_type(&tok!('='), "=")?;
expect!(self, ';');
Ok(Box::new(TsTypeAliasDecl {
declare: false,
span: span!(self, start),
id: id.into(),
type_params,
type_ann,
}))
}
/// `tsParseImportEqualsDeclaration`
pub(super) fn parse_ts_import_equals_decl(
&mut self,
start: BytePos,
id: Ident,
is_export: bool,
is_type_only: bool,
) -> PResult<Box<TsImportEqualsDecl>> {
debug_assert!(self.input.syntax().typescript());
expect!(self, '=');
let module_ref = self.parse_ts_module_ref()?;
expect!(self, ';');
Ok(Box::new(TsImportEqualsDecl {
span: span!(self, start),
id,
is_export,
is_type_only,
module_ref,
}))
}
/// `tsIsExternalModuleReference`
fn is_ts_external_module_ref(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
Ok(is!(self, "require") && peeked_is!(self, '('))
}
/// `tsParseModuleReference`
fn parse_ts_module_ref(&mut self) -> PResult<TsModuleRef> {
debug_assert!(self.input.syntax().typescript());
if self.is_ts_external_module_ref()? {
self.parse_ts_external_module_ref().map(From::from)
} else {
self.parse_ts_entity_name(/* allow_reserved_words */ false)
.map(From::from)
}
}
/// `tsParseExternalModuleReference`
fn parse_ts_external_module_ref(&mut self) -> PResult<TsExternalModuleRef> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
expect!(self, "require");
expect!(self, '(');
match *cur!(self, true) {
Token::Str { .. } => {}
_ => unexpected!(self, "a string literal"),
}
let expr = match self.parse_lit()? {
Lit::Str(s) => s,
_ => unreachable!(),
};
expect!(self, ')');
Ok(TsExternalModuleRef {
span: span!(self, start),
expr,
})
}
pub(super) fn ts_look_ahead<T, F>(&mut self, op: F) -> PResult<T>
where
F: FnOnce(&mut Self) -> PResult<T>,
{
debug_assert!(self.input.syntax().typescript());
let mut cloned = self.clone();
let ctx = Context {
ignore_error: true,
..cloned.ctx()
};
cloned.set_ctx(ctx);
op(&mut cloned)
}
/// `tsIsUnambiguouslyStartOfFunctionType`
fn is_ts_unambiguously_start_of_fn_type(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
assert_and_bump!(self, '(');
if is_one_of!(self, ')', "...") {
// ( )
// ( ...
return Ok(true);
}
if self.skip_ts_parameter_start()? {
if is_one_of!(self, ':', ',', '?', '=') {
// ( xxx :
// ( xxx ,
// ( xxx ?
// ( xxx =
return Ok(true);
}
if eat!(self, ')') && is!(self, "=>") {
// ( xxx ) =>
return Ok(true);
}
}
Ok(false)
}
/// `tsSkipParameterStart`
fn skip_ts_parameter_start(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
let _ = self.eat_any_ts_modifier()?;
if is_one_of!(self, IdentName, "this") {
bump!(self);
return Ok(true);
}
if (is!(self, '{') || is!(self, '[')) && self.parse_binding_pat_or_ident(false).is_ok() {
return Ok(true);
}
Ok(false)
}
/// `tsParseTypeMemberSemicolon`
fn parse_ts_type_member_semicolon(&mut self) -> PResult<()> {
debug_assert!(self.input.syntax().typescript());
if !eat!(self, ',') {
expect!(self, ';');
}
Ok(())
}
/// `tsParseSignatureMember`
fn parse_ts_signature_member(
&mut self,
kind: SignatureParsingMode,
) -> PResult<Either<TsCallSignatureDecl, TsConstructSignatureDecl>> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
if kind == SignatureParsingMode::TSConstructSignatureDeclaration {
expect!(self, "new");
}
// ----- inlined self.tsFillSignature(tt.colon, node);
let type_params = self.try_parse_ts_type_params(false, true)?;
expect!(self, '(');
let params = self.parse_ts_binding_list_for_signature()?;
let type_ann = if is!(self, ':') {
Some(self.parse_ts_type_or_type_predicate_ann(&tok!(':'))?)
} else {
None
};
// -----
self.parse_ts_type_member_semicolon()?;
match kind {
SignatureParsingMode::TSCallSignatureDeclaration => {
Ok(Either::Left(TsCallSignatureDecl {
span: span!(self, start),
params,
type_ann,
type_params,
}))
}
SignatureParsingMode::TSConstructSignatureDeclaration => {
Ok(Either::Right(TsConstructSignatureDecl {
span: span!(self, start),
params,
type_ann,
type_params,
}))
}
}
}
/// `tsIsUnambiguouslyIndexSignature`
fn is_ts_unambiguously_index_signature(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
// Note: babel's comment is wrong
assert_and_bump!(self, '['); // Skip '['
// ',' is for error recovery
Ok(eat!(self, IdentRef) && is_one_of!(self, ':', ','))
}
/// `tsTryParseIndexSignature`
pub(super) fn try_parse_ts_index_signature(
&mut self,
index_signature_start: BytePos,
readonly: bool,
is_static: bool,
) -> PResult<Option<TsIndexSignature>> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
if !(is!(self, '[') && self.ts_look_ahead(|p| p.is_ts_unambiguously_index_signature())?) {
return Ok(None);
}
expect!(self, '[');
let ident_start = cur_pos!(self);
let mut id = self.parse_ident_name().map(BindingIdent::from)?;
let type_ann_start = cur_pos!(self);
if eat!(self, ',') {
self.emit_err(id.span, SyntaxError::TS1096);
} else {
expect!(self, ':');
}
let type_ann = self.parse_ts_type_ann(/* eat_colon */ false, type_ann_start)?;
id.span = span!(self, ident_start);
id.type_ann = Some(type_ann);
expect!(self, ']');
let params = vec![TsFnParam::Ident(id)];
let ty = self.try_parse_ts_type_ann()?;
let type_ann = ty;
self.parse_ts_type_member_semicolon()?;
Ok(Some(TsIndexSignature {
span: span!(self, index_signature_start),
readonly,
is_static,
params,
type_ann,
}))
}
/// `parsePropertyName` in babel.
///
/// Returns `(computed, key)`.
fn parse_ts_property_name(&mut self) -> PResult<(bool, Box<Expr>)> {
let (computed, key) = if eat!(self, '[') {
let key = self.parse_assignment_expr()?;
expect!(self, ']');
(true, key)
} else {
let ctx = Context {
in_property_name: true,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
// We check if it's valid for it to be a private name when we push it.
let key = match *cur!(p, true) {
Token::Num { .. } | Token::Str { .. } => p.parse_new_expr(),
_ => p.parse_maybe_private_name().map(|e| match e {
Either::Left(e) => {
p.emit_err(e.span(), SyntaxError::PrivateNameInInterface);
e.into()
}
Either::Right(e) => e.into(),
}),
};
key.map(|key| (false, key))
})?
};
Ok((computed, key))
}
/// `tsParsePropertyOrMethodSignature`
fn parse_ts_property_or_method_signature(
&mut self,
start: BytePos,
readonly: bool,
) -> PResult<Either<TsPropertySignature, TsMethodSignature>> {
debug_assert!(self.input.syntax().typescript());
let (computed, key) = self.parse_ts_property_name()?;
let optional = eat!(self, '?');
if is_one_of!(self, '(', '<') {
if readonly {
syntax_error!(self, SyntaxError::ReadOnlyMethod)
}
let type_params = self.try_parse_ts_type_params(false, true)?;
expect!(self, '(');
let params = self.parse_ts_binding_list_for_signature()?;
let type_ann = if is!(self, ':') {
self.parse_ts_type_or_type_predicate_ann(&tok!(':'))
.map(Some)?
} else {
None
};
// -----
self.parse_ts_type_member_semicolon()?;
Ok(Either::Right(TsMethodSignature {
span: span!(self, start),
computed,
key,
optional,
type_params,
params,
type_ann,
}))
} else {
let type_ann = self.try_parse_ts_type_ann()?;
self.parse_ts_type_member_semicolon()?;
Ok(Either::Left(TsPropertySignature {
span: span!(self, start),
computed,
readonly,
key,
optional,
type_ann,
}))
}
}
/// `tsParseTypeMember`
fn parse_ts_type_member(&mut self) -> PResult<TsTypeElement> {
debug_assert!(self.input.syntax().typescript());
fn into_type_elem(
e: Either<TsCallSignatureDecl, TsConstructSignatureDecl>,
) -> TsTypeElement {
match e {
Either::Left(e) => e.into(),
Either::Right(e) => e.into(),
}
}
if is_one_of!(self, '(', '<') {
return self
.parse_ts_signature_member(SignatureParsingMode::TSCallSignatureDeclaration)
.map(into_type_elem);
}
if is!(self, "new") && self.ts_look_ahead(|p| p.is_ts_start_of_construct_signature())? {
return self
.parse_ts_signature_member(SignatureParsingMode::TSConstructSignatureDeclaration)
.map(into_type_elem);
}
// Instead of fullStart, we create a node here.
let start = cur_pos!(self);
let readonly = self.parse_ts_modifier(&["readonly"], false)?.is_some();
let idx = self.try_parse_ts_index_signature(start, readonly, false)?;
if let Some(idx) = idx {
return Ok(idx.into());
}
if let Some(v) = self.try_parse_ts(|p| {
let start = p.input.cur_pos();
if readonly {
syntax_error!(p, SyntaxError::GetterSetterCannotBeReadonly)
}
let is_get = if eat!(p, "get") {
true
} else {
expect!(p, "set");
false
};
let (computed, key) = p.parse_ts_property_name()?;
if is_get {
expect!(p, '(');
expect!(p, ')');
let type_ann = p.try_parse_ts_type_ann()?;
p.parse_ts_type_member_semicolon()?;
Ok(Some(TsTypeElement::TsGetterSignature(TsGetterSignature {
span: span!(p, start),
key,
computed,
type_ann,
})))
} else {
expect!(p, '(');
let params = p.parse_ts_binding_list_for_signature()?;
if params.is_empty() {
syntax_error!(p, SyntaxError::SetterParamRequired)
}
let param = params.into_iter().next().unwrap();
p.parse_ts_type_member_semicolon()?;
Ok(Some(TsTypeElement::TsSetterSignature(TsSetterSignature {
span: span!(p, start),
key,
computed,
param,
})))
}
}) {
return Ok(v);
}
self.parse_ts_property_or_method_signature(start, readonly)
.map(|e| match e {
Either::Left(e) => e.into(),
Either::Right(e) => e.into(),
})
}
/// `tsIsStartOfConstructSignature`
fn is_ts_start_of_construct_signature(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
bump!(self);
Ok(is!(self, '(') || is!(self, '<'))
}
/// `tsParseTypeLiteral`
fn parse_ts_type_lit(&mut self) -> PResult<TsTypeLit> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let members = self.parse_ts_object_type_members()?;
Ok(TsTypeLit {
span: span!(self, start),
members,
})
}
/// `tsParseObjectTypeMembers`
fn parse_ts_object_type_members(&mut self) -> PResult<Vec<TsTypeElement>> {
debug_assert!(self.input.syntax().typescript());
expect!(self, '{');
let members =
self.parse_ts_list(ParsingContext::TypeMembers, |p| p.parse_ts_type_member())?;
expect!(self, '}');
Ok(members)
}
/// `tsIsStartOfMappedType`
fn is_ts_start_of_mapped_type(&mut self) -> PResult<bool> {
debug_assert!(self.input.syntax().typescript());
bump!(self);
if eat!(self, '+') || eat!(self, '-') {
return Ok(is!(self, "readonly"));
}
if is!(self, "readonly") {
bump!(self);
}
if !is!(self, '[') {
return Ok(false);
}
bump!(self);
if !is!(self, IdentRef) {
return Ok(false);
}
bump!(self);
Ok(is!(self, "in"))
}
/// `tsParseMappedTypeParameter`
fn parse_ts_mapped_type_param(&mut self) -> PResult<TsTypeParam> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let name = self.parse_ident_name()?;
let constraint = Some(self.expect_then_parse_ts_type(&tok!("in"), "in")?);
Ok(TsTypeParam {
span: span!(self, start),
name: name.into(),
is_in: false,
is_out: false,
is_const: false,
constraint,
default: None,
})
}
/// `tsParseMappedType`
fn parse_ts_mapped_type(&mut self) -> PResult<TsMappedType> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
expect!(self, '{');
let mut readonly = None;
if is_one_of!(self, '+', '-') {
readonly = Some(if is!(self, '+') {
TruePlusMinus::Plus
} else {
TruePlusMinus::Minus
});
bump!(self);
expect!(self, "readonly")
} else if eat!(self, "readonly") {
readonly = Some(TruePlusMinus::True);
}
expect!(self, '[');
let type_param = self.parse_ts_mapped_type_param()?;
let name_type = if eat!(self, "as") {
Some(self.parse_ts_type()?)
} else {
None
};
expect!(self, ']');
let mut optional = None;
if is_one_of!(self, '+', '-') {
optional = Some(if is!(self, '+') {
TruePlusMinus::Plus
} else {
TruePlusMinus::Minus
});
bump!(self); // +, -
expect!(self, '?');
} else if eat!(self, '?') {
optional = Some(TruePlusMinus::True);
}
let type_ann = self.try_parse_ts_type()?;
expect!(self, ';');
expect!(self, '}');
Ok(TsMappedType {
span: span!(self, start),
readonly,
optional,
type_param,
name_type,
type_ann,
})
}
/// `tsParseTupleType`
fn parse_ts_tuple_type(&mut self) -> PResult<TsTupleType> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let elems = self.parse_ts_bracketed_list(
ParsingContext::TupleElementTypes,
|p| p.parse_ts_tuple_element_type(),
/* bracket */ true,
/* skipFirstToken */ false,
)?;
// Validate the elementTypes to ensure:
// No mandatory elements may follow optional elements
// If there's a rest element, it must be at the end of the tuple
let mut seen_optional_element = false;
for elem in elems.iter() {
match *elem.ty {
TsType::TsRestType(..) => {}
TsType::TsOptionalType(..) => {
seen_optional_element = true;
}
_ if seen_optional_element => {
syntax_error!(
self,
span!(self, start),
SyntaxError::TsRequiredAfterOptional
)
}
_ => {}
}
}
Ok(TsTupleType {
span: span!(self, start),
elem_types: elems,
})
}
fn try_parse_ts_tuple_element_name(&mut self) -> Option<Pat> {
if !cfg!(feature = "typescript") {
return Default::default();
}
self.try_parse_ts(|p| {
let start = cur_pos!(p);
let rest = if eat!(p, "...") {
Some(p.input.prev_span())
} else {
None
};
let mut ident = p.parse_ident_name().map(Ident::from)?;
if eat!(p, '?') {
ident.optional = true;
ident.span = ident.span.with_hi(p.input.prev_span().hi);
}
expect!(p, ':');
Ok(Some(if let Some(dot3_token) = rest {
RestPat {
span: span!(p, start),
dot3_token,
arg: ident.into(),
type_ann: None,
}
.into()
} else {
ident.into()
}))
})
}
/// `tsParseTupleElementType`
fn parse_ts_tuple_element_type(&mut self) -> PResult<TsTupleElement> {
debug_assert!(self.input.syntax().typescript());
// parses `...TsType[]`
let start = cur_pos!(self);
let label = self.try_parse_ts_tuple_element_name();
if eat!(self, "...") {
let type_ann = self.parse_ts_type()?;
return Ok(TsTupleElement {
span: span!(self, start),
label,
ty: Box::new(TsType::TsRestType(TsRestType {
span: span!(self, start),
type_ann,
})),
});
}
let ty = self.parse_ts_type()?;
// parses `TsType?`
if eat!(self, '?') {
let type_ann = ty;
return Ok(TsTupleElement {
span: span!(self, start),
label,
ty: Box::new(TsType::TsOptionalType(TsOptionalType {
span: span!(self, start),
type_ann,
})),
});
}
Ok(TsTupleElement {
span: span!(self, start),
label,
ty,
})
}
/// `tsParseParenthesizedType`
fn parse_ts_parenthesized_type(&mut self) -> PResult<TsParenthesizedType> {
debug_assert!(self.input.syntax().typescript());
trace_cur!(self, parse_ts_parenthesized_type);
let start = cur_pos!(self);
expect!(self, '(');
let type_ann = self.parse_ts_type()?;
expect!(self, ')');
Ok(TsParenthesizedType {
span: span!(self, start),
type_ann,
})
}
/// `tsParseFunctionOrConstructorType`
fn parse_ts_fn_or_constructor_type(
&mut self,
is_fn_type: bool,
) -> PResult<TsFnOrConstructorType> {
trace_cur!(self, parse_ts_fn_or_constructor_type);
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let is_abstract = if !is_fn_type {
eat!(self, "abstract")
} else {
false
};
if !is_fn_type {
expect!(self, "new");
}
// ----- inlined `self.tsFillSignature(tt.arrow, node)`
let type_params = self.try_parse_ts_type_params(false, true)?;
expect!(self, '(');
let params = self.parse_ts_binding_list_for_signature()?;
let type_ann = self.parse_ts_type_or_type_predicate_ann(&tok!("=>"))?;
// ----- end
Ok(if is_fn_type {
TsFnOrConstructorType::TsFnType(TsFnType {
span: span!(self, start),
type_params,
params,
type_ann,
})
} else {
TsFnOrConstructorType::TsConstructorType(TsConstructorType {
span: span!(self, start),
type_params,
params,
type_ann,
is_abstract,
})
})
}
/// `tsParseLiteralTypeNode`
fn parse_ts_lit_type_node(&mut self) -> PResult<TsLitType> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let lit = if is!(self, '`') {
let tpl = self.parse_ts_tpl_lit_type()?;
TsLit::Tpl(tpl)
} else {
match self.parse_lit()? {
Lit::BigInt(n) => TsLit::BigInt(n),
Lit::Bool(n) => TsLit::Bool(n),
Lit::Num(n) => TsLit::Number(n),
Lit::Str(n) => TsLit::Str(n),
_ => unreachable!(),
}
};
Ok(TsLitType {
span: span!(self, start),
lit,
})
}
/// `tsParseTemplateLiteralType`
fn parse_ts_tpl_lit_type(&mut self) -> PResult<TsTplLitType> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
assert_and_bump!(self, '`');
let (types, quasis) = self.parse_ts_tpl_type_elements()?;
expect!(self, '`');
Ok(TsTplLitType {
span: span!(self, start),
types,
quasis,
})
}
fn parse_ts_tpl_type_elements(&mut self) -> PResult<(Vec<Box<TsType>>, Vec<TplElement>)> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
trace_cur!(self, parse_tpl_elements);
let mut types = Vec::new();
let cur_elem = self.parse_tpl_element(false)?;
let mut is_tail = cur_elem.tail;
let mut quasis = vec![cur_elem];
while !is_tail {
expect!(self, "${");
types.push(self.parse_ts_type()?);
expect!(self, '}');
let elem = self.parse_tpl_element(false)?;
is_tail = elem.tail;
quasis.push(elem);
}
Ok((types, quasis))
}
/// `tsParseBindingListForSignature`
///
/// Eats ')` at the end but does not eat `(` at start.
fn parse_ts_binding_list_for_signature(&mut self) -> PResult<Vec<TsFnParam>> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
debug_assert!(self.input.syntax().typescript());
let params = self.parse_formal_params()?;
let mut list = Vec::new();
for param in params {
let item = match param.pat {
Pat::Ident(pat) => TsFnParam::Ident(pat),
Pat::Array(pat) => TsFnParam::Array(pat),
Pat::Object(pat) => TsFnParam::Object(pat),
Pat::Rest(pat) => TsFnParam::Rest(pat),
_ => unexpected!(
self,
"an identifier, [ for an array pattern, { for an object patter or ... for a \
rest pattern"
),
};
list.push(item);
}
expect!(self, ')');
Ok(list)
}
/// `tsTryParseTypeOrTypePredicateAnnotation`
///
/// Used for parsing return types.
fn try_parse_ts_type_or_type_predicate_ann(&mut self) -> PResult<Option<Box<TsTypeAnn>>> {
if !cfg!(feature = "typescript") {
return Ok(None);
}
if is!(self, ':') {
self.parse_ts_type_or_type_predicate_ann(&tok!(':'))
.map(Some)
} else {
Ok(None)
}
}
/// `tsTryParseTypeAnnotation`
#[cfg_attr(feature = "tracing-spans", tracing::instrument(skip_all))]
pub(super) fn try_parse_ts_type_ann(&mut self) -> PResult<Option<Box<TsTypeAnn>>> {
if !cfg!(feature = "typescript") {
return Ok(None);
}
if is!(self, ':') {
let pos = cur_pos!(self);
return self.parse_ts_type_ann(/* eat_colon */ true, pos).map(Some);
}
Ok(None)
}
/// `tsTryParseType`
fn try_parse_ts_type(&mut self) -> PResult<Option<Box<TsType>>> {
if !cfg!(feature = "typescript") {
return Ok(None);
}
self.eat_then_parse_ts_type(&tok!(':'))
}
/// `tsTryParseTypeParameters`
pub(super) fn try_parse_ts_type_params(
&mut self,
permit_in_out: bool,
permit_const: bool,
) -> PResult<Option<Box<TsTypeParamDecl>>> {
if !cfg!(feature = "typescript") {
return Ok(None);
}
if is!(self, '<') {
return self
.parse_ts_type_params(permit_in_out, permit_const)
.map(Some);
}
Ok(None)
}
/// `tsParseNonArrayType`
fn parse_ts_non_array_type(&mut self) -> PResult<Box<TsType>> {
if !cfg!(feature = "typescript") {
unreachable!()
}
trace_cur!(self, parse_ts_non_array_type);
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
match *cur!(self, true) {
Token::Word(Word::Ident(..))
| tok!("void")
| tok!("yield")
| tok!("null")
| tok!("await")
| tok!("break") => {
if is!(self, "asserts") && peeked_is!(self, "this") {
bump!(self);
let this_keyword = self.parse_ts_this_type_node()?;
return self
.parse_ts_this_type_predicate(start, true, this_keyword)
.map(TsType::from)
.map(Box::new);
}
let kind = if is!(self, "void") {
Some(TsKeywordTypeKind::TsVoidKeyword)
} else if is!(self, "null") {
Some(TsKeywordTypeKind::TsNullKeyword)
} else if is!(self, "any") {
Some(TsKeywordTypeKind::TsAnyKeyword)
} else if is!(self, "boolean") {
Some(TsKeywordTypeKind::TsBooleanKeyword)
} else if is!(self, "bigint") {
Some(TsKeywordTypeKind::TsBigIntKeyword)
} else if is!(self, "never") {
Some(TsKeywordTypeKind::TsNeverKeyword)
} else if is!(self, "number") {
Some(TsKeywordTypeKind::TsNumberKeyword)
} else if is!(self, "object") {
Some(TsKeywordTypeKind::TsObjectKeyword)
} else if is!(self, "string") {
Some(TsKeywordTypeKind::TsStringKeyword)
} else if is!(self, "symbol") {
Some(TsKeywordTypeKind::TsSymbolKeyword)
} else if is!(self, "unknown") {
Some(TsKeywordTypeKind::TsUnknownKeyword)
} else if is!(self, "undefined") {
Some(TsKeywordTypeKind::TsUndefinedKeyword)
} else if is!(self, "intrinsic") {
Some(TsKeywordTypeKind::TsIntrinsicKeyword)
} else {
None
};
let peeked_is_dot = peeked_is!(self, '.');
match kind {
Some(kind) if !peeked_is_dot => {
bump!(self);
return Ok(Box::new(TsType::TsKeywordType(TsKeywordType {
span: span!(self, start),
kind,
})));
}
_ => {
return self.parse_ts_type_ref().map(TsType::from).map(Box::new);
}
}
}
Token::BigInt { .. }
| Token::Str { .. }
| Token::Num { .. }
| tok!("true")
| tok!("false")
| tok!('`') => {
return self
.parse_ts_lit_type_node()
.map(TsType::from)
.map(Box::new);
}
tok!('-') => {
let start = cur_pos!(self);
bump!(self);
if !matches!(*cur!(self, true), Token::Num { .. } | Token::BigInt { .. }) {
unexpected!(self, "numeric literal or bigint literal")
}
let lit = self.parse_lit()?;
let lit = match lit {
Lit::Num(Number { span, value, raw }) => {
let mut new_raw = String::from("-");
match raw {
Some(raw) => {
new_raw.push_str(&raw);
}
_ => {
write!(new_raw, "{}", value).unwrap();
}
};
TsLit::Number(Number {
span,
value: -value,
raw: Some(new_raw.into()),
})
}
Lit::BigInt(BigInt { span, value, raw }) => {
let mut new_raw = String::from("-");
match raw {
Some(raw) => {
new_raw.push_str(&raw);
}
_ => {
write!(new_raw, "{}", value).unwrap();
}
};
TsLit::BigInt(BigInt {
span,
value: Box::new(-*value),
raw: Some(new_raw.into()),
})
}
_ => unreachable!(),
};
return Ok(Box::new(TsType::TsLitType(TsLitType {
span: span!(self, start),
lit,
})));
}
tok!("import") => {
return self.parse_ts_import_type().map(TsType::from).map(Box::new);
}
tok!("this") => {
let start = cur_pos!(self);
let this_keyword = self.parse_ts_this_type_node()?;
if !self.input.had_line_break_before_cur() && is!(self, "is") {
return self
.parse_ts_this_type_predicate(start, false, this_keyword)
.map(TsType::from)
.map(Box::new);
} else {
return Ok(Box::new(TsType::TsThisType(this_keyword)));
}
}
tok!("typeof") => {
return self.parse_ts_type_query().map(TsType::from).map(Box::new);
}
tok!('{') => {
return if self.ts_look_ahead(|p| p.is_ts_start_of_mapped_type())? {
self.parse_ts_mapped_type().map(TsType::from).map(Box::new)
} else {
self.parse_ts_type_lit().map(TsType::from).map(Box::new)
};
}
tok!('[') => {
return self.parse_ts_tuple_type().map(TsType::from).map(Box::new);
}
tok!('(') => {
return self
.parse_ts_parenthesized_type()
.map(TsType::from)
.map(Box::new);
}
_ => {}
}
// switch (self.state.type) {
// }
unexpected!(
self,
"an identifier, void, yield, null, await, break, a string literal, a numeric literal, \
true, false, `, -, import, this, typeof, {, [, ("
)
}
/// `tsParseArrayTypeOrHigher`
fn parse_ts_array_type_or_higher(&mut self, readonly: bool) -> PResult<Box<TsType>> {
trace_cur!(self, parse_ts_array_type_or_higher);
debug_assert!(self.input.syntax().typescript());
let mut ty = self.parse_ts_non_array_type()?;
while !self.input.had_line_break_before_cur() && eat!(self, '[') {
if eat!(self, ']') {
ty = Box::new(TsType::TsArrayType(TsArrayType {
span: span!(self, ty.span_lo()),
elem_type: ty,
}));
} else {
let index_type = self.parse_ts_type()?;
expect!(self, ']');
ty = Box::new(TsType::TsIndexedAccessType(TsIndexedAccessType {
span: span!(self, ty.span_lo()),
readonly,
obj_type: ty,
index_type,
}))
}
}
Ok(ty)
}
/// `tsParseTypeOperator`
fn parse_ts_type_operator(&mut self, op: TsTypeOperatorOp) -> PResult<TsTypeOperator> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
match op {
TsTypeOperatorOp::Unique => expect!(self, "unique"),
TsTypeOperatorOp::KeyOf => expect!(self, "keyof"),
TsTypeOperatorOp::ReadOnly => expect!(self, "readonly"),
}
let type_ann = self.parse_ts_type_operator_or_higher()?;
Ok(TsTypeOperator {
span: span!(self, start),
op,
type_ann,
})
}
/// `tsParseInferType`
fn parse_ts_infer_type(&mut self) -> PResult<TsInferType> {
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
expect!(self, "infer");
let type_param_name = self.parse_ident_name()?;
let constraint = self.try_parse_ts(|p| {
expect!(p, "extends");
let constraint = p.parse_ts_non_conditional_type();
if p.ctx().disallow_conditional_types || !is!(p, '?') {
constraint.map(Some)
} else {
Ok(None)
}
});
let type_param = TsTypeParam {
span: type_param_name.span(),
name: type_param_name.into(),
is_in: false,
is_out: false,
is_const: false,
constraint,
default: None,
};
Ok(TsInferType {
span: span!(self, start),
type_param,
})
}
/// `tsParseTypeOperatorOrHigher`
fn parse_ts_type_operator_or_higher(&mut self) -> PResult<Box<TsType>> {
trace_cur!(self, parse_ts_type_operator_or_higher);
debug_assert!(self.input.syntax().typescript());
let operator = if is!(self, "keyof") {
Some(TsTypeOperatorOp::KeyOf)
} else if is!(self, "unique") {
Some(TsTypeOperatorOp::Unique)
} else if is!(self, "readonly") {
Some(TsTypeOperatorOp::ReadOnly)
} else {
None
};
match operator {
Some(operator) => self
.parse_ts_type_operator(operator)
.map(TsType::from)
.map(Box::new),
None => {
trace_cur!(self, parse_ts_type_operator_or_higher__not_operator);
if is!(self, "infer") {
self.parse_ts_infer_type().map(TsType::from).map(Box::new)
} else {
let readonly = self.parse_ts_modifier(&["readonly"], false)?.is_some();
self.parse_ts_array_type_or_higher(readonly)
}
}
}
}
/// `tsParseExpressionStatement`
pub(super) fn parse_ts_expr_stmt(
&mut self,
decorators: Vec<Decorator>,
expr: Ident,
) -> PResult<Option<Decl>> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
let start = expr.span_lo();
match &*expr.sym {
"declare" => {
let decl = self.try_parse_ts_declare(start, decorators)?;
if let Some(decl) = decl {
Ok(Some(make_decl_declare(decl)))
} else {
Ok(None)
}
}
"global" => {
// `global { }` (with no `declare`) may appear inside an ambient module
// declaration.
// Would like to use tsParseAmbientExternalModuleDeclaration here, but already
// ran past "global".
if is!(self, '{') {
let global = true;
let id = TsModuleName::Ident(expr);
let body = self
.parse_ts_module_block()
.map(TsNamespaceBody::from)
.map(Some)?;
Ok(Some(
TsModuleDecl {
span: span!(self, start),
global,
declare: false,
namespace: false,
id,
body,
}
.into(),
))
} else {
Ok(None)
}
}
_ => self.parse_ts_decl(start, decorators, expr.sym, /* next */ false),
}
}
/// `tsTryParseDeclare`
pub(super) fn try_parse_ts_declare(
&mut self,
start: BytePos,
decorators: Vec<Decorator>,
) -> PResult<Option<Decl>> {
if !self.syntax().typescript() {
return Ok(None);
}
if self.ctx().in_declare
&& matches!(
self.syntax(),
Syntax::Typescript(TsSyntax { dts: false, .. })
)
{
let span_of_declare = span!(self, start);
self.emit_err(span_of_declare, SyntaxError::TS1038);
}
let declare_start = start;
let ctx = Context {
in_declare: true,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
if is!(p, "function") {
return p
.parse_fn_decl(decorators)
.map(|decl| match decl {
Decl::Fn(f) => FnDecl {
declare: true,
function: Box::new(Function {
span: Span {
lo: declare_start,
..f.function.span
},
..*f.function
}),
..f
}
.into(),
_ => decl,
})
.map(Some);
}
if is!(p, "class") {
return p
.parse_class_decl(start, start, decorators, false)
.map(|decl| match decl {
Decl::Class(c) => ClassDecl {
declare: true,
class: Box::new(Class {
span: Span {
lo: declare_start,
..c.class.span
},
..*c.class
}),
..c
}
.into(),
_ => decl,
})
.map(Some);
}
if is!(p, "const") && peeked_is!(p, "enum") {
assert_and_bump!(p, "const");
let _ = cur!(p, true);
assert_and_bump!(p, "enum");
return p
.parse_ts_enum_decl(start, /* is_const */ true)
.map(|decl| TsEnumDecl {
declare: true,
span: Span {
lo: declare_start,
..decl.span
},
..*decl
})
.map(Box::new)
.map(From::from)
.map(Some);
}
if is_one_of!(p, "const", "var", "let") {
return p
.parse_var_stmt(false)
.map(|decl| VarDecl {
declare: true,
span: Span {
lo: declare_start,
..decl.span
},
..*decl
})
.map(Box::new)
.map(From::from)
.map(Some);
}
if is!(p, "global") {
return p
.parse_ts_ambient_external_module_decl(start)
.map(Decl::from)
.map(make_decl_declare)
.map(Some);
} else if is!(p, IdentName) {
let value = match *cur!(p, true) {
Token::Word(ref w) => w.clone().into(),
_ => unreachable!(),
};
return p
.parse_ts_decl(start, decorators, value, /* next */ true)
.map(|v| v.map(make_decl_declare));
}
Ok(None)
})
}
/// `tsTryParseExportDeclaration`
///
/// Note: this won't be called unless the keyword is allowed in
/// `shouldParseExportDeclaration`.
pub(super) fn try_parse_ts_export_decl(
&mut self,
decorators: Vec<Decorator>,
value: Atom,
) -> Option<Decl> {
if !cfg!(feature = "typescript") {
return None;
}
self.try_parse_ts(|p| {
let start = cur_pos!(p);
let opt = p.parse_ts_decl(start, decorators, value, true)?;
Ok(opt)
})
}
/// Common to tsTryParseDeclare, tsTryParseExportDeclaration, and
/// tsParseExpressionStatement.
///
/// `tsParseDeclaration`
fn parse_ts_decl(
&mut self,
start: BytePos,
decorators: Vec<Decorator>,
value: Atom,
next: bool,
) -> PResult<Option<Decl>> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
match &*value {
"abstract" => {
if next || (is!(self, "class") && !self.input.had_line_break_before_cur()) {
if next {
bump!(self);
}
return Ok(Some(self.parse_class_decl(start, start, decorators, true)?));
}
}
"enum" => {
if next || is!(self, IdentRef) {
if next {
bump!(self);
}
return self
.parse_ts_enum_decl(start, /* is_const */ false)
.map(From::from)
.map(Some);
}
}
"interface" => {
if next || (is!(self, IdentRef)) {
if next {
bump!(self);
}
return self
.parse_ts_interface_decl(start)
.map(From::from)
.map(Some);
}
}
"module" if !self.input.had_line_break_before_cur() => {
if next {
bump!(self);
}
if matches!(*cur!(self, true), Token::Str { .. }) {
return self
.parse_ts_ambient_external_module_decl(start)
.map(From::from)
.map(Some);
} else if next || is!(self, IdentRef) {
return self
.parse_ts_module_or_ns_decl(start, false)
.map(From::from)
.map(Some);
}
}
"namespace" => {
if next || is!(self, IdentRef) {
if next {
bump!(self);
}
return self
.parse_ts_module_or_ns_decl(start, true)
.map(From::from)
.map(Some);
}
}
"type" => {
if next || (!self.input.had_line_break_before_cur() && is!(self, IdentRef)) {
if next {
bump!(self);
}
return self
.parse_ts_type_alias_decl(start)
.map(From::from)
.map(Some);
}
}
_ => {}
}
Ok(None)
}
/// `tsTryParseGenericAsyncArrowFunction`
pub(super) fn try_parse_ts_generic_async_arrow_fn(
&mut self,
start: BytePos,
) -> PResult<Option<ArrowExpr>> {
if !cfg!(feature = "typescript") {
return Ok(Default::default());
}
let res = if is_one_of!(self, '<', JSXTagStart) {
self.try_parse_ts(|p| {
let type_params = p.parse_ts_type_params(false, false)?;
// Don't use overloaded parseFunctionParams which would look for "<" again.
expect!(p, '(');
let params: Vec<Pat> = p
.parse_formal_params()?
.into_iter()
.map(|p| p.pat)
.collect();
expect!(p, ')');
let return_type = p.try_parse_ts_type_or_type_predicate_ann()?;
expect!(p, "=>");
Ok(Some((type_params, params, return_type)))
})
} else {
None
};
let (type_params, params, return_type) = match res {
Some(v) => v,
None => return Ok(None),
};
let ctx = Context {
in_async: true,
in_generator: false,
..self.ctx()
};
self.with_ctx(ctx).parse_with(|p| {
let is_generator = false;
let is_async = true;
let body = p.parse_fn_body(true, false, true, params.is_simple_parameter_list())?;
Ok(Some(ArrowExpr {
span: span!(p, start),
body,
is_async,
is_generator,
type_params: Some(type_params),
params,
return_type,
..Default::default()
}))
})
}
/// `tsParseTypeArguments`
pub fn parse_ts_type_args(&mut self) -> PResult<Box<TsTypeParamInstantiation>> {
trace_cur!(self, parse_ts_type_args);
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self);
let params = self.in_type().parse_with(|p| {
// Temporarily remove a JSX parsing context, which makes us scan different
// tokens.
p.ts_in_no_context(|p| {
if is!(p, "<<") {
p.input.cut_lshift();
} else {
expect!(p, '<');
}
p.parse_ts_delimited_list(ParsingContext::TypeParametersOrArguments, |p| {
trace_cur!(p, parse_ts_type_args__arg);
p.parse_ts_type()
})
})
})?;
// This reads the next token after the `>` too, so do this in the enclosing
// context. But be sure not to parse a regex in the jsx expression
// `<C<number> />`, so set exprAllowed = false
self.input.set_expr_allowed(false);
expect!(self, '>');
Ok(Box::new(TsTypeParamInstantiation {
span: span!(self, start),
params,
}))
}
/// `tsParseIntersectionTypeOrHigher`
fn parse_ts_intersection_type_or_higher(&mut self) -> PResult<Box<TsType>> {
trace_cur!(self, parse_ts_intersection_type_or_higher);
debug_assert!(self.input.syntax().typescript());
self.parse_ts_union_or_intersection_type(
UnionOrIntersection::Intersection,
|p| p.parse_ts_type_operator_or_higher(),
&tok!('&'),
)
}
/// `tsParseUnionTypeOrHigher`
fn parse_ts_union_type_or_higher(&mut self) -> PResult<Box<TsType>> {
trace_cur!(self, parse_ts_union_type_or_higher);
debug_assert!(self.input.syntax().typescript());
self.parse_ts_union_or_intersection_type(
UnionOrIntersection::Union,
|p| p.parse_ts_intersection_type_or_higher(),
&tok!('|'),
)
}
/// `tsParseUnionOrIntersectionType`
fn parse_ts_union_or_intersection_type<F>(
&mut self,
kind: UnionOrIntersection,
mut parse_constituent_type: F,
operator: &'static Token,
) -> PResult<Box<TsType>>
where
F: FnMut(&mut Self) -> PResult<Box<TsType>>,
{
trace_cur!(self, parse_ts_union_or_intersection_type);
debug_assert!(self.input.syntax().typescript());
let start = cur_pos!(self); // include the leading operator in the start
self.input.eat(operator);
trace_cur!(self, parse_ts_union_or_intersection_type__first_type);
let ty = parse_constituent_type(self)?;
trace_cur!(self, parse_ts_union_or_intersection_type__after_first);
if self.input.is(operator) {
let mut types = vec![ty];
while self.input.eat(operator) {
trace_cur!(self, parse_ts_union_or_intersection_type__constituent);
types.push(parse_constituent_type(self)?);
}
return Ok(Box::new(TsType::TsUnionOrIntersectionType(match kind {
UnionOrIntersection::Union => TsUnionOrIntersectionType::TsUnionType(TsUnionType {
span: span!(self, start),
types,
}),
UnionOrIntersection::Intersection => {
TsUnionOrIntersectionType::TsIntersectionType(TsIntersectionType {
span: span!(self, start),
types,
})
}
})));
}
Ok(ty)
}
}
impl<I: Tokens> Parser<I> {
/// In no lexer context
fn ts_in_no_context<T, F>(&mut self, op: F) -> PResult<T>
where
F: FnOnce(&mut Self) -> PResult<T>,
{
debug_assert!(self.input.syntax().typescript());
trace_cur!(self, ts_in_no_context__before);
let cloned = self.input.token_context().clone();
self.input
.set_token_context(TokenContexts(smallvec::smallvec![cloned.0[0]]));
let res = op(self);
self.input.set_token_context(cloned);
trace_cur!(self, ts_in_no_context__after);
res
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum UnionOrIntersection {
Union,
Intersection,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ParsingContext {
EnumMembers,
HeritageClauseElement,
TupleElementTypes,
TypeMembers,
TypeParametersOrArguments,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum SignatureParsingMode {
TSCallSignatureDeclaration,
TSConstructSignatureDeclaration,
}
/// Mark as declare
fn make_decl_declare(mut decl: Decl) -> Decl {
match decl {
Decl::Class(ref mut c) => c.declare = true,
Decl::Fn(ref mut f) => f.declare = true,
Decl::Var(ref mut v) => v.declare = true,
Decl::TsInterface(ref mut i) => i.declare = true,
Decl::TsTypeAlias(ref mut a) => a.declare = true,
Decl::TsEnum(ref mut e) => e.declare = true,
Decl::TsModule(ref mut m) => m.declare = true,
Decl::Using(..) => unreachable!("Using is not a valid declaration for `declare` keyword"),
}
decl
}
#[cfg(test)]
mod tests {
use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_visit::assert_eq_ignore_span;
use crate::{lexer::Lexer, test_parser, token::*, Capturing, Parser, Syntax};
#[test]
fn issue_708_1() {
let actual = test_parser(
"type test = -1;",
Syntax::Typescript(Default::default()),
|p| p.parse_module(),
);
let expected = Module {
span: DUMMY_SP,
shebang: None,
body: {
let first = TsTypeAliasDecl {
span: DUMMY_SP,
declare: false,
id: Ident::new_no_ctxt("test".into(), DUMMY_SP),
type_params: None,
type_ann: Box::new(TsType::TsLitType(TsLitType {
span: DUMMY_SP,
lit: TsLit::Number(Number {
span: DUMMY_SP,
value: -1.0,
raw: Some("-1".into()),
}),
})),
}
.into();
vec![first]
},
};
assert_eq_ignore_span!(actual, expected);
}
#[test]
fn issue_708_2() {
let actual = test_parser(
"const t = -1;",
Syntax::Typescript(Default::default()),
|p| p.parse_module(),
);
let expected = Module {
span: DUMMY_SP,
shebang: None,
body: {
let second = VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(Ident::new_no_ctxt("t".into(), DUMMY_SP).into()),
init: Some(Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: op!(unary, "-"),
arg: Box::new(Expr::Lit(Lit::Num(Number {
span: DUMMY_SP,
value: 1.0,
raw: Some("1".into()),
}))),
}))),
definite: false,
}],
..Default::default()
}
.into();
vec![second]
},
};
assert_eq_ignore_span!(actual, expected);
}
#[test]
fn issue_726() {
crate::with_test_sess(
"type Test = (
string | number);",
|handler, input| {
let lexer = Lexer::new(
Syntax::Typescript(Default::default()),
EsVersion::Es2019,
input,
None,
);
let lexer = Capturing::new(lexer);
let mut parser = Parser::new_from(lexer);
parser
.parse_typescript_module()
.map_err(|e| e.into_diagnostic(handler).emit())?;
let tokens: Vec<TokenAndSpan> = parser.input().take();
let tokens = tokens.into_iter().map(|t| t.token).collect::<Vec<_>>();
assert_eq!(tokens.len(), 9, "Tokens: {:#?}", tokens);
Ok(())
},
)
.unwrap();
}
#[test]
fn issue_751() {
crate::with_test_sess("t ? -(v >>> 1) : v >>> 1", |handler, input| {
let lexer = Lexer::new(
Syntax::Typescript(Default::default()),
EsVersion::Es2019,
input,
None,
);
let lexer = Capturing::new(lexer);
let mut parser = Parser::new_from(lexer);
parser
.parse_typescript_module()
.map_err(|e| e.into_diagnostic(handler).emit())?;
let tokens: Vec<TokenAndSpan> = parser.input().take();
let token = &tokens[10];
assert_eq!(
token.token,
Token::BinOp(BinOpToken::ZeroFillRShift),
"Token: {:#?}",
token.token
);
Ok(())
})
.unwrap();
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/parser/util.rs | Rust | use super::*;
use crate::token::{IdentLike, Keyword};
impl Context {
pub(crate) fn is_reserved(self, word: &Word) -> bool {
match *word {
Word::Keyword(Keyword::Let) => self.strict,
Word::Keyword(Keyword::Await) => self.in_async || self.in_static_block || self.strict,
Word::Keyword(Keyword::Yield) => self.in_generator || self.strict,
Word::Null
| Word::True
| Word::False
| Word::Keyword(Keyword::Break)
| Word::Keyword(Keyword::Case)
| Word::Keyword(Keyword::Catch)
| Word::Keyword(Keyword::Continue)
| Word::Keyword(Keyword::Debugger)
| Word::Keyword(Keyword::Default_)
| Word::Keyword(Keyword::Do)
| Word::Keyword(Keyword::Export)
| Word::Keyword(Keyword::Else)
| Word::Keyword(Keyword::Finally)
| Word::Keyword(Keyword::For)
| Word::Keyword(Keyword::Function)
| Word::Keyword(Keyword::If)
| Word::Keyword(Keyword::Return)
| Word::Keyword(Keyword::Switch)
| Word::Keyword(Keyword::Throw)
| Word::Keyword(Keyword::Try)
| Word::Keyword(Keyword::Var)
| Word::Keyword(Keyword::Const)
| Word::Keyword(Keyword::While)
| Word::Keyword(Keyword::With)
| Word::Keyword(Keyword::New)
| Word::Keyword(Keyword::This)
| Word::Keyword(Keyword::Super)
| Word::Keyword(Keyword::Class)
| Word::Keyword(Keyword::Extends)
| Word::Keyword(Keyword::Import)
| Word::Keyword(Keyword::In)
| Word::Keyword(Keyword::InstanceOf)
| Word::Keyword(Keyword::TypeOf)
| Word::Keyword(Keyword::Void)
| Word::Keyword(Keyword::Delete) => true,
// Future reserved word
Word::Ident(IdentLike::Known(known_ident!("enum"))) => true,
Word::Ident(IdentLike::Known(
known_ident!("implements")
| known_ident!("package")
| known_ident!("protected")
| known_ident!("interface")
| known_ident!("private")
| known_ident!("public"),
)) if self.strict => true,
_ => false,
}
}
#[cfg_attr(not(feature = "verify"), inline(always))]
pub fn is_reserved_word(self, word: &Atom) -> bool {
if !cfg!(feature = "verify") {
return false;
}
match &**word {
"let" => self.strict,
// SyntaxError in the module only, not in the strict.
// ```JavaScript
// function foo() {
// "use strict";
// let await = 1;
// }
// ```
"await" => self.in_async || self.in_static_block || self.module,
"yield" => self.in_generator || self.strict,
"null" | "true" | "false" | "break" | "case" | "catch" | "continue" | "debugger"
| "default" | "do" | "export" | "else" | "finally" | "for" | "function" | "if"
| "return" | "switch" | "throw" | "try" | "var" | "const" | "while" | "with"
| "new" | "this" | "super" | "class" | "extends" | "import" | "in" | "instanceof"
| "typeof" | "void" | "delete" => true,
// Future reserved word
"enum" => true,
"implements" | "package" | "protected" | "interface" | "private" | "public"
if self.strict =>
{
true
}
_ => false,
}
}
}
impl<I: Tokens> Parser<I> {
/// Original context is restored when returned guard is dropped.
pub(super) fn with_ctx(&mut self, ctx: Context) -> WithCtx<I> {
let orig_ctx = self.ctx();
self.set_ctx(ctx);
WithCtx {
orig_ctx,
inner: self,
}
}
/// Original state is restored when returned guard is dropped.
pub(super) fn with_state(&mut self, state: State) -> WithState<I> {
let orig_state = std::mem::replace(&mut self.state, state);
WithState {
orig_state,
inner: self,
}
}
pub(super) fn set_ctx(&mut self, ctx: Context) {
self.input.set_ctx(ctx);
}
pub(super) fn strict_mode(&mut self) -> WithCtx<I> {
let ctx = Context {
strict: true,
..self.ctx()
};
self.with_ctx(ctx)
}
/// Original context is restored when returned guard is dropped.
pub(super) fn in_type(&mut self) -> WithCtx<I> {
let ctx = Context {
in_type: true,
..self.ctx()
};
self.with_ctx(ctx)
}
/// Original context is restored when returned guard is dropped.
pub(super) fn include_in_expr(&mut self, include_in_expr: bool) -> WithCtx<I> {
let ctx = Context {
include_in_expr,
..self.ctx()
};
self.with_ctx(ctx)
}
/// Parse with given closure
#[inline(always)]
pub(super) fn parse_with<F, Ret>(&mut self, f: F) -> PResult<Ret>
where
F: FnOnce(&mut Self) -> PResult<Ret>,
{
f(self)
}
pub(super) fn syntax(&self) -> Syntax {
self.input.syntax()
}
}
pub trait ParseObject<Obj> {
type Prop;
fn make_object(
&mut self,
span: Span,
props: Vec<Self::Prop>,
trailing_comma: Option<Span>,
) -> PResult<Obj>;
fn parse_object_prop(&mut self) -> PResult<Self::Prop>;
}
pub struct WithState<'w, I: 'w + Tokens> {
inner: &'w mut Parser<I>,
orig_state: State,
}
impl<I: Tokens> Deref for WithState<'_, I> {
type Target = Parser<I>;
fn deref(&self) -> &Parser<I> {
self.inner
}
}
impl<I: Tokens> DerefMut for WithState<'_, I> {
fn deref_mut(&mut self) -> &mut Parser<I> {
self.inner
}
}
impl<I: Tokens> Drop for WithState<'_, I> {
fn drop(&mut self) {
std::mem::swap(&mut self.inner.state, &mut self.orig_state);
}
}
pub struct WithCtx<'w, I: 'w + Tokens> {
inner: &'w mut Parser<I>,
orig_ctx: Context,
}
impl<I: Tokens> Deref for WithCtx<'_, I> {
type Target = Parser<I>;
fn deref(&self) -> &Parser<I> {
self.inner
}
}
impl<I: Tokens> DerefMut for WithCtx<'_, I> {
fn deref_mut(&mut self) -> &mut Parser<I> {
self.inner
}
}
impl<I: Tokens> Drop for WithCtx<'_, I> {
fn drop(&mut self) {
self.inner.set_ctx(self.orig_ctx);
}
}
pub(super) trait ExprExt {
fn as_expr(&self) -> &Expr;
/// "IsValidSimpleAssignmentTarget" from spec.
fn is_valid_simple_assignment_target(&self, strict: bool) -> bool {
match self.as_expr() {
Expr::Ident(ident) => {
if strict && ident.is_reserved_in_strict_bind() {
return false;
}
true
}
Expr::This(..)
| Expr::Lit(..)
| Expr::Array(..)
| Expr::Object(..)
| Expr::Fn(..)
| Expr::Class(..)
| Expr::Tpl(..)
| Expr::TaggedTpl(..) => false,
Expr::Paren(ParenExpr { expr, .. }) => expr.is_valid_simple_assignment_target(strict),
Expr::Member(MemberExpr { obj, .. }) => match obj.as_ref() {
Expr::Member(..) => obj.is_valid_simple_assignment_target(strict),
Expr::OptChain(..) => false,
_ => true,
},
Expr::SuperProp(..) => true,
Expr::New(..) | Expr::Call(..) => false,
// TODO: Spec only mentions `new.target`
Expr::MetaProp(..) => false,
Expr::Update(..) => false,
Expr::Unary(..) | Expr::Await(..) => false,
Expr::Bin(..) => false,
Expr::Cond(..) => false,
Expr::Yield(..) | Expr::Arrow(..) | Expr::Assign(..) => false,
Expr::Seq(..) => false,
Expr::OptChain(..) => false,
// MemberExpression is valid assignment target
Expr::PrivateName(..) => false,
// jsx
Expr::JSXMember(..)
| Expr::JSXNamespacedName(..)
| Expr::JSXEmpty(..)
| Expr::JSXElement(..)
| Expr::JSXFragment(..) => false,
// typescript
Expr::TsNonNull(TsNonNullExpr { ref expr, .. })
| Expr::TsTypeAssertion(TsTypeAssertion { ref expr, .. })
| Expr::TsAs(TsAsExpr { ref expr, .. })
| Expr::TsInstantiation(TsInstantiation { ref expr, .. })
| Expr::TsSatisfies(TsSatisfiesExpr { ref expr, .. }) => {
expr.is_valid_simple_assignment_target(strict)
}
Expr::TsConstAssertion(..) => false,
Expr::Invalid(..) => false,
}
}
}
impl ExprExt for Box<Expr> {
fn as_expr(&self) -> &Expr {
self
}
}
impl ExprExt for Expr {
fn as_expr(&self) -> &Expr {
self
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/src/token.rs | Rust | //! Ported from [babel/babylon][]
//!
//! [babel/babylon]:https://github.com/babel/babel/blob/2d378d076eb0c5fe63234a8b509886005c01d7ee/packages/babylon/src/tokenizer/types.js
use std::{
borrow::Cow,
fmt::{self, Debug, Display, Formatter},
};
use num_bigint::BigInt as BigIntValue;
use swc_atoms::{atom, Atom, AtomStore};
use swc_common::{Span, Spanned};
pub(crate) use swc_ecma_ast::{AssignOp, BinaryOp};
pub(crate) use self::{Keyword::*, Token::*};
use crate::{error::Error, lexer::LexResult};
macro_rules! define_known_ident {
(
$(
$name:ident => $value:tt,
)*
) => {
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum KnownIdent {
$(
$name
),*
}
#[allow(unused)]
macro_rules! known_ident_token {
$(
($value) => {
crate::token::TokenKind::Word(crate::token::WordKind::Ident(
crate::token::IdentKind::Known(crate::token::KnownIdent::$name),
))
};
)*
}
#[allow(unused)]
macro_rules! known_ident {
$(
($value) => {
crate::token::KnownIdent::$name
};
)*
}
#[allow(unused)]
macro_rules! ident_like {
$(
($value) => {
crate::token::IdentLike::Known(
crate::token::KnownIdent::$name
)
};
)*
}
static STR_TO_KNOWN_IDENT: phf::Map<&'static str, KnownIdent> = phf::phf_map! {
$(
$value => KnownIdent::$name,
)*
};
impl From<KnownIdent> for Atom {
fn from(s: KnownIdent) -> Self {
match s {
$(
KnownIdent::$name => atom!($value),
)*
}
}
}
impl From<KnownIdent> for &'static str {
fn from(s: KnownIdent) -> Self {
match s {
$(
KnownIdent::$name => $value,
)*
}
}
}
};
}
define_known_ident!(
Abstract => "abstract",
As => "as",
Async => "async",
From => "from",
Of => "of",
Type => "type",
Global => "global",
Static => "static",
Using => "using",
Readonly => "readonly",
Unique => "unique",
Keyof => "keyof",
Declare => "declare",
Enum => "enum",
Is => "is",
Infer => "infer",
Symbol => "symbol",
Undefined => "undefined",
Interface => "interface",
Implements => "implements",
Asserts => "asserts",
Require => "require",
Get => "get",
Set => "set",
Any => "any",
Intrinsic => "intrinsic",
Unknown => "unknown",
String => "string",
Object => "object",
Number => "number",
Bigint => "bigint",
Boolean => "boolean",
Never => "never",
Assert => "assert",
Namespace => "namespace",
Accessor => "accessor",
Meta => "meta",
Target => "target",
Satisfies => "satisfies",
Package => "package",
Protected => "protected",
Private => "private",
Public => "public",
);
impl std::str::FromStr for KnownIdent {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
STR_TO_KNOWN_IDENT.get(s).cloned().ok_or(())
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum WordKind {
Keyword(Keyword),
Null,
True,
False,
Ident(IdentKind),
}
impl From<Keyword> for WordKind {
#[inline(always)]
fn from(kwd: Keyword) -> Self {
Self::Keyword(kwd)
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum IdentKind {
Known(KnownIdent),
Other,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum TokenKind {
Word(WordKind),
Arrow,
Hash,
At,
Dot,
DotDotDot,
Bang,
LParen,
RParen,
LBracket,
RBracket,
LBrace,
RBrace,
Semi,
Comma,
BackQuote,
Template,
Colon,
BinOp(BinOpToken),
AssignOp(AssignOp),
DollarLBrace,
QuestionMark,
PlusPlus,
MinusMinus,
Tilde,
Str,
/// We abuse `token.raw` for flags
Regex,
Num,
BigInt,
JSXName,
JSXText,
JSXTagStart,
JSXTagEnd,
Shebang,
Error,
}
#[derive(Clone, PartialEq)]
pub enum Token {
/// Identifier, "null", "true", "false".
///
/// Contains `null` and ``
Word(Word),
/// '=>'
Arrow,
/// '#'
Hash,
/// '@'
At,
/// '.'
Dot,
/// '...'
DotDotDot,
/// '!'
Bang,
/// '('
LParen,
/// ')'
RParen,
/// `[`
LBracket,
/// ']'
RBracket,
/// '{'
LBrace,
/// '}'
RBrace,
/// ';'
Semi,
/// ','
Comma,
/// '`'
BackQuote,
Template {
raw: Atom,
cooked: LexResult<Atom>,
},
/// ':'
Colon,
BinOp(BinOpToken),
AssignOp(AssignOp),
/// '${'
DollarLBrace,
/// '?'
QuestionMark,
/// `++`
PlusPlus,
/// `--`
MinusMinus,
/// `~`
Tilde,
/// String literal. Span of this token contains quote.
Str {
value: Atom,
raw: Atom,
},
/// Regexp literal.
Regex(Atom, Atom),
/// TODO: Make Num as enum and separate decimal, binary, ..etc
Num {
value: f64,
raw: Atom,
},
BigInt {
value: Box<BigIntValue>,
raw: Atom,
},
JSXName {
name: Atom,
},
JSXText {
value: Atom,
raw: Atom,
},
JSXTagStart,
JSXTagEnd,
Shebang(Atom),
Error(Error),
}
impl Token {
pub(crate) fn kind(&self) -> TokenKind {
match self {
Self::Arrow => TokenKind::Arrow,
Self::Hash => TokenKind::Hash,
Self::At => TokenKind::At,
Self::Dot => TokenKind::Dot,
Self::DotDotDot => TokenKind::DotDotDot,
Self::Bang => TokenKind::Bang,
Self::LParen => TokenKind::LParen,
Self::RParen => TokenKind::RParen,
Self::LBracket => TokenKind::LBracket,
Self::RBracket => TokenKind::RBracket,
Self::LBrace => TokenKind::LBrace,
Self::RBrace => TokenKind::RBrace,
Self::Semi => TokenKind::Semi,
Self::Comma => TokenKind::Comma,
Self::BackQuote => TokenKind::BackQuote,
Self::Template { .. } => TokenKind::Template,
Self::Colon => TokenKind::Colon,
Self::BinOp(op) => TokenKind::BinOp(*op),
Self::AssignOp(op) => TokenKind::AssignOp(*op),
Self::DollarLBrace => TokenKind::DollarLBrace,
Self::QuestionMark => TokenKind::QuestionMark,
Self::PlusPlus => TokenKind::PlusPlus,
Self::MinusMinus => TokenKind::MinusMinus,
Self::Tilde => TokenKind::Tilde,
Self::Str { .. } => TokenKind::Str,
Self::Regex(..) => TokenKind::Regex,
Self::Num { .. } => TokenKind::Num,
Self::BigInt { .. } => TokenKind::BigInt,
Self::JSXName { .. } => TokenKind::JSXName,
Self::JSXText { .. } => TokenKind::JSXText,
Self::JSXTagStart => TokenKind::JSXTagStart,
Self::JSXTagEnd => TokenKind::JSXTagEnd,
Self::Shebang(..) => TokenKind::Shebang,
Self::Error(..) => TokenKind::Error,
Self::Word(w) => TokenKind::Word(w.kind()),
}
}
}
impl TokenKind {
pub(crate) const fn before_expr(self) -> bool {
match self {
Self::Word(w) => w.before_expr(),
Self::BinOp(w) => w.before_expr(),
Self::Arrow
| Self::DotDotDot
| Self::Bang
| Self::LParen
| Self::LBrace
| Self::LBracket
| Self::Semi
| Self::Comma
| Self::Colon
| Self::AssignOp(..)
| Self::DollarLBrace
| Self::QuestionMark
| Self::PlusPlus
| Self::MinusMinus
| Self::Tilde
| Self::JSXText { .. } => true,
_ => false,
}
}
pub(crate) const fn starts_expr(self) -> bool {
match self {
Self::Word(w) => w.starts_expr(),
Self::BinOp(w) => w.starts_expr(),
Self::Bang
| Self::LParen
| Self::LBrace
| Self::LBracket
| Self::BackQuote
| Self::DollarLBrace
| Self::PlusPlus
| Self::MinusMinus
| Self::Tilde
| Self::Str
| Self::Regex
| Self::Num
| Self::BigInt
| Self::JSXTagStart => true,
_ => false,
}
}
}
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub enum BinOpToken {
/// `==`
EqEq,
/// `!=`
NotEq,
/// `===`
EqEqEq,
/// `!==`
NotEqEq,
/// `<`
Lt,
/// `<=`
LtEq,
/// `>`
Gt,
/// `>=`
GtEq,
/// `<<`
LShift,
/// `>>`
RShift,
/// `>>>`
ZeroFillRShift,
/// `+`
Add,
/// `-`
Sub,
/// `*`
Mul,
/// `/`
Div,
/// `%`
Mod,
/// `|`
BitOr,
/// `^`
BitXor,
/// `&`
BitAnd,
// /// `in`
// #[kind(precedence = "7")]
// In,
// /// `instanceof`
// #[kind(precedence = "7")]
// InstanceOf,
/// `**`
Exp,
/// `||`
LogicalOr,
/// `&&`
LogicalAnd,
/// `??`
NullishCoalescing,
}
impl BinOpToken {
pub(crate) const fn starts_expr(self) -> bool {
matches!(self, Self::Add | Self::Sub)
}
pub(crate) const fn before_expr(self) -> bool {
true
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct TokenAndSpan {
pub token: Token,
/// Had a line break before this token?
pub had_line_break: bool,
pub span: Span,
}
impl Spanned for TokenAndSpan {
#[inline]
fn span(&self) -> Span {
self.span
}
}
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum Word {
Keyword(Keyword),
Null,
True,
False,
Ident(IdentLike),
}
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum IdentLike {
Known(KnownIdent),
Other(Atom),
}
impl From<&'_ str> for IdentLike {
fn from(s: &str) -> Self {
s.parse::<KnownIdent>()
.map(Self::Known)
.unwrap_or_else(|_| Self::Other(s.into()))
}
}
impl IdentLike {
pub(crate) fn from_str(atoms: &mut AtomStore, s: &str) -> IdentLike {
s.parse::<KnownIdent>()
.map(Self::Known)
.unwrap_or_else(|_| Self::Other(atoms.atom(s)))
}
}
impl Word {
pub fn from_str(atoms: &mut AtomStore, s: &str) -> Self {
match s {
"null" => Word::Null,
"true" => Word::True,
"false" => Word::False,
"await" => Await.into(),
"break" => Break.into(),
"case" => Case.into(),
"catch" => Catch.into(),
"continue" => Continue.into(),
"debugger" => Debugger.into(),
"default" => Default_.into(),
"do" => Do.into(),
"export" => Export.into(),
"else" => Else.into(),
"finally" => Finally.into(),
"for" => For.into(),
"function" => Function.into(),
"if" => If.into(),
"return" => Return.into(),
"switch" => Switch.into(),
"throw" => Throw.into(),
"try" => Try.into(),
"var" => Var.into(),
"let" => Let.into(),
"const" => Const.into(),
"while" => While.into(),
"with" => With.into(),
"new" => New.into(),
"this" => This.into(),
"super" => Super.into(),
"class" => Class.into(),
"extends" => Extends.into(),
"import" => Import.into(),
"yield" => Yield.into(),
"in" => In.into(),
"instanceof" => InstanceOf.into(),
"typeof" => TypeOf.into(),
"void" => Void.into(),
"delete" => Delete.into(),
_ => Word::Ident(IdentLike::from_str(atoms, s)),
}
}
pub(crate) fn kind(&self) -> WordKind {
match self {
Word::Keyword(k) => WordKind::Keyword(*k),
Word::Null => WordKind::Null,
Word::True => WordKind::True,
Word::False => WordKind::False,
Word::Ident(IdentLike::Known(i)) => WordKind::Ident(IdentKind::Known(*i)),
Word::Ident(IdentLike::Other(..)) => WordKind::Ident(IdentKind::Other),
}
}
}
impl WordKind {
pub(crate) const fn before_expr(self) -> bool {
match self {
Self::Keyword(k) => k.before_expr(),
_ => false,
}
}
pub(crate) const fn starts_expr(self) -> bool {
match self {
Self::Keyword(k) => k.starts_expr(),
_ => true,
}
}
}
impl AsRef<str> for IdentLike {
fn as_ref(&self) -> &str {
match self {
IdentLike::Known(k) => (*k).into(),
IdentLike::Other(s) => s.as_ref(),
}
}
}
impl From<Keyword> for Word {
fn from(kwd: Keyword) -> Self {
Word::Keyword(kwd)
}
}
impl From<Word> for Atom {
fn from(w: Word) -> Self {
match w {
Word::Keyword(k) => match k {
Await => "await",
Break => "break",
Case => "case",
Catch => "catch",
Continue => "continue",
Debugger => "debugger",
Default_ => "default",
Do => "do",
Else => "else",
Finally => "finally",
For => "for",
Function => "function",
If => "if",
Return => "return",
Switch => "switch",
Throw => "throw",
Try => "try",
Var => "var",
Let => "let",
Const => "const",
While => "while",
With => "with",
New => "new",
This => "this",
Super => "super",
Class => "class",
Extends => "extends",
Export => "export",
Import => "import",
Yield => "yield",
In => "in",
InstanceOf => "instanceof",
TypeOf => "typeof",
Void => "void",
Delete => "delete",
}
.into(),
Word::Null => "null".into(),
Word::True => "true".into(),
Word::False => "false".into(),
Word::Ident(w) => w.into(),
}
}
}
impl From<IdentLike> for Atom {
fn from(i: IdentLike) -> Self {
match i {
IdentLike::Known(i) => i.into(),
IdentLike::Other(i) => i,
}
}
}
impl Debug for Word {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match *self {
Word::Ident(ref s) => Display::fmt(s, f),
_ => {
let s: Atom = self.clone().into();
Display::fmt(&s, f)
}
}
}
}
impl Display for IdentLike {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match *self {
IdentLike::Known(ref s) => Display::fmt(s, f),
IdentLike::Other(ref s) => Display::fmt(s, f),
}
}
}
impl Display for KnownIdent {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let s: &'static str = (*self).into();
Display::fmt(s, f)
}
}
macro_rules! declare_keyword {
($(
$name:ident => $value:tt,
)*) => {
impl Keyword {
pub(crate) fn into_atom(self) -> Atom {
match self {
$(Keyword::$name => atom!($value),)*
}
}
}
};
}
declare_keyword!(
Await => "await",
Break => "break",
Case => "case",
Catch => "catch",
Continue => "continue",
Debugger => "debugger",
Default_ => "default",
Do => "do",
Else => "else",
Finally => "finally",
For => "for",
Function => "function",
If => "if",
Return => "return",
Switch => "switch",
Throw => "throw",
Try => "try",
Var => "var",
Let => "let",
Const => "const",
While => "while",
With => "with",
New => "new",
This => "this",
Super => "super",
Class => "class",
Extends => "extends",
Export => "export",
Import => "import",
Yield => "yield",
In => "in",
InstanceOf => "instanceof",
TypeOf => "typeof",
Void => "void",
Delete => "delete",
);
/// Keywords
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub enum Keyword {
/// Spec says this might be identifier.
Await,
Break,
Case,
Catch,
Continue,
Debugger,
Default_,
Do,
Else,
Finally,
For,
Function,
If,
Return,
Switch,
Throw,
Try,
Var,
Let,
Const,
While,
With,
New,
This,
Super,
Class,
Extends,
Export,
Import,
/// Spec says this might be identifier.
Yield,
In,
InstanceOf,
TypeOf,
Void,
Delete,
}
impl Keyword {
pub(crate) const fn before_expr(self) -> bool {
matches!(
self,
Self::Await
| Self::Case
| Self::Default_
| Self::Do
| Self::Else
| Self::Return
| Self::Throw
| Self::New
| Self::Extends
| Self::Yield
| Self::In
| Self::InstanceOf
| Self::TypeOf
| Self::Void
| Self::Delete
)
}
pub(crate) const fn starts_expr(self) -> bool {
matches!(
self,
Self::Await
| Self::Function
| Self::Throw
| Self::New
| Self::This
| Self::Super
| Self::Class
| Self::Import
| Self::Yield
| Self::TypeOf
| Self::Void
| Self::Delete
)
}
}
impl Debug for Keyword {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "keyword '{}'", self.into_atom())?;
Ok(())
}
}
impl From<BinOpToken> for BinaryOp {
fn from(t: BinOpToken) -> Self {
use self::BinaryOp::*;
match t {
BinOpToken::EqEq => EqEq,
BinOpToken::NotEq => NotEq,
BinOpToken::EqEqEq => EqEqEq,
BinOpToken::NotEqEq => NotEqEq,
BinOpToken::Lt => Lt,
BinOpToken::LtEq => LtEq,
BinOpToken::Gt => Gt,
BinOpToken::GtEq => GtEq,
BinOpToken::LShift => LShift,
BinOpToken::RShift => RShift,
BinOpToken::ZeroFillRShift => ZeroFillRShift,
BinOpToken::Add => Add,
BinOpToken::Sub => Sub,
BinOpToken::Mul => Mul,
BinOpToken::Div => Div,
BinOpToken::Mod => Mod,
BinOpToken::BitOr => BitOr,
BinOpToken::BitXor => BitXor,
BinOpToken::BitAnd => BitAnd,
BinOpToken::LogicalOr => LogicalOr,
BinOpToken::LogicalAnd => LogicalAnd,
BinOpToken::Exp => Exp,
BinOpToken::NullishCoalescing => NullishCoalescing,
}
}
}
impl TokenKind {
/// Returns true if `self` can follow keyword let.
///
/// e.g. `let a = xx;`, `let {a:{}} = 1`
pub(crate) fn follows_keyword_let(self, _strict: bool) -> bool {
match self {
Self::Word(WordKind::Keyword(Keyword::Let))
| TokenKind::LBrace
| TokenKind::LBracket
| Self::Word(WordKind::Ident(..))
| TokenKind::Word(WordKind::Keyword(Keyword::Yield))
| TokenKind::Word(WordKind::Keyword(Keyword::Await)) => true,
_ => false,
}
}
}
impl Word {
pub(crate) fn cow(&self) -> Cow<Atom> {
match self {
Word::Keyword(k) => Cow::Owned(k.into_atom()),
Word::Ident(IdentLike::Known(w)) => Cow::Owned((*w).into()),
Word::Ident(IdentLike::Other(w)) => Cow::Borrowed(w),
Word::False => Cow::Owned(atom!("false")),
Word::True => Cow::Owned(atom!("true")),
Word::Null => Cow::Owned(atom!("null")),
}
}
}
impl Debug for Token {
/// This method is called only in the case of parsing failure.
#[cold]
#[inline(never)]
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match self {
Token::Word(w) => write!(f, "{:?}", w)?,
Arrow => write!(f, "=>")?,
Hash => write!(f, "#")?,
At => write!(f, "@")?,
Dot => write!(f, ".")?,
DotDotDot => write!(f, "...")?,
Bang => write!(f, "!")?,
LParen => write!(f, "(")?,
RParen => write!(f, ")")?,
LBracket => write!(f, "[")?,
RBracket => write!(f, "]")?,
LBrace => write!(f, "{{")?,
RBrace => write!(f, "}}")?,
Semi => write!(f, ";")?,
Comma => write!(f, ",")?,
BackQuote => write!(f, "`")?,
Template { raw, .. } => write!(f, "template token ({})", raw)?,
Colon => write!(f, ":")?,
BinOp(op) => write!(f, "{}", BinaryOp::from(*op).as_str())?,
AssignOp(op) => write!(f, "{}", op.as_str())?,
DollarLBrace => write!(f, "${{")?,
QuestionMark => write!(f, "?")?,
PlusPlus => write!(f, "++")?,
MinusMinus => write!(f, "--")?,
Tilde => write!(f, "~")?,
Str { value, raw } => write!(f, "string literal ({}, {})", value, raw)?,
Regex(exp, flags) => write!(f, "regexp literal ({}, {})", exp, flags)?,
Num { value, raw, .. } => write!(f, "numeric literal ({}, {})", value, raw)?,
BigInt { value, raw } => write!(f, "bigint literal ({}, {})", value, raw)?,
JSXName { name } => write!(f, "jsx name ({})", name)?,
JSXText { raw, .. } => write!(f, "jsx text ({})", raw)?,
JSXTagStart => write!(f, "< (jsx tag start)")?,
JSXTagEnd => write!(f, "> (jsx tag end)")?,
Shebang(_) => write!(f, "#!")?,
Token::Error(e) => write!(f, "<lexing error: {:?}>", e)?,
}
Ok(())
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/binding-pattern/description.js | JavaScript | // self - local self
// ArrayBindingPattern -> [Elision? BindingRestElement -> BindingIdentifier]
/*
* ArrayBindingPattern
* Elision = ,
* BindingRestElement = ... SELF | ... identifier
* BindingElementList = ,? BindingElement | self ,? BindingElement
* BindingElement = identifier = _ | SELF = _
*
* */
let simple_array = [1, 2, 3, 4, 5, 6]
let multi_array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
let multi_array_2 = [[[1, 2, 3, 4], [5, 6, 7, 8, 9]]]
let obj = {
num: 10,
null: null,
nested: {nested: {val: "val"}, array: simple_array},
s_array: simple_array,
m_array: multi_array
}
// ------- BindingPattern = SELF
{
let [...tail] = simple_array // [ 1, 2, 3, 4, 5, 6 ]
let [, ...tail_1] = simple_array // [ 2, 3, 4, 5, 6 ]
let [, , , ...tail_2] = simple_array // [ 4, 5, 6 ]
// ArrayBindingPattern -> [Elision? BindingRestElement -> BindingPattern -> ArrayBindingPattern -> [Elision? BindingRestElement -> BindingIdentifier]]
let [...[...tail_3]] = multi_array // [[ 1, 2, 3 ],[ 4, 5, 6 ],[ 7, 8, 9 ]]
let [...[...tail_4]] = multi_array_2 // [ [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8, 9 ] ] ]
let [...[...[...tail_5]]] = multi_array_2 // [ [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8, 9 ] ] ]
let [, ...[, ...tail_6]] = multi_array // [ [ 7, 8, 9 ] ]
let [, ...[, ...tail_7]] = multi_array_2 // []
let [, ...[, , ...tail_8]] = [1, 2, 3, [4, 5, 6, 7]] // [ [ 4, 5, 6, 7 ] ]
// ArrayBindingPattern -> [Elision? BindingRestElement -> BindingPattern -> ObjectBindingPattern ... ]
// ArrayBindingPattern -> [BindingElementList -> BindingElisionElement -> BindingElement -> SingleNameBinding]
let [a = 10] = simple_array // 1
let [, ab = 10, , ,] = simple_array // 2
let [, , , ba = ab] = simple_array // 4
// ArrayBindingPattern -> [BindingElementList -> BindingElisionElement -> BindingElement -> BindingPattern]
// ArrayBindingPattern -> [BindingElementList,Elision? BindingRestElement]
let [, v1, , ...v_rest] = simple_array // 2 [ 4, 5, 6 ]
/*
* ObjectBindingPattern
* {}
* {BindingRestProperty} = ... id
* {BindingPropertyList} = BindingProperty | self,BindingProperty
* {BindingPropertyList,BindingRestProperty }
* BindingProperty = id = _ | PropertyName : id = _ | PropertyName : SELF = _
* PropertyName = ((UnicodeIDStart | $ | _ ) (UnicodeIDContinue | $ | <ZWNJ> <ZWJ> ) | "string" | 'string' | num | [ _ ]
* */
// ObjectBindingPattern -> {}
let {} = obj // {}
// ObjectBindingPattern -> {BindingRestProperty}
let {...obj2} = obj // obj
var {...obj3} = obj // obj
// ObjectBindingPattern -> {BindingPropertyList}
let {simple_prop = 10} = obj // 10
let {obj_prop = {value: prop2 = 10}, prop3 = [1]} = obj // obj_prop = {value:10},prop2 = 10
let {obj1 = {$: num = 10, '': sym = '', " ": quote = " ", _: under = [...tail],}} = obj // obj_prop = {value:10},prop2 = 10
}
// ----------------- //
// Spots
// PrimaryExpression -> (...SELF) | (Expression, ...SELF)
// LexicalDeclaration[ -> (let | const) SELF
// Iteration Statements -> for((var | let | const) SELF (in | of) ...)
// TryStatement -> try{...} catch(SELF){...}
class MyError extends Error {
constructor(name1, name2) {
super();
this.name1 = name1;
this.name2 = name2;
}
}
try {
let err = new MyError("name1", "name2")
err.code = "code"
throw err
} catch ({name1, name2, code, ...rest}) {
console.log(name1, name2, code, rest)
}
for (let [, , t] = simple_array; t < 10; t++) {
// console.log(t)
}
for (let {num} = obj; num < 11; num++) {
// console.log(num)
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments.rs | Rust | use std::path::PathBuf;
use swc_common::{
comments::SingleThreadedComments,
errors::{DiagnosticBuilder, Handler},
input::SourceFileInput,
BytePos, Span,
};
use swc_ecma_ast::*;
use swc_ecma_parser::{lexer::Lexer, EsSyntax, Parser, Syntax, TsSyntax};
use swc_ecma_visit::{Visit, VisitWith};
use testing::{fixture, Tester};
#[fixture("tests/comments/**/input.js")]
fn test(input: PathBuf) {
let ext = input.extension().unwrap();
let ext = ext.to_string_lossy();
let output_file = PathBuf::from(format!("{}.swc-stderr", input.display()));
let output = Tester::new()
.print_errors(|cm, handler| -> Result<(), _> {
//
let fm = cm.load_file(&input).unwrap();
let syntax = match &*ext {
"js" => Syntax::Es(EsSyntax {
jsx: false,
fn_bind: false,
decorators: true,
decorators_before_export: false,
export_default_from: true,
import_attributes: true,
..Default::default()
}),
"ts" | "tsx" => Syntax::Typescript(TsSyntax {
tsx: ext == "tsx",
decorators: true,
no_early_errors: true,
..Default::default()
}),
_ => {
unreachable!()
}
};
let comments = SingleThreadedComments::default();
let lexer = Lexer::new(
syntax,
EsVersion::latest(),
SourceFileInput::from(&*fm),
Some(&comments),
);
let mut parser = Parser::new_from(lexer);
let module = parser.parse_module();
let module = match module {
Ok(v) => v,
Err(err) => {
panic!("{:?}", err)
}
};
module.visit_with(&mut CommentPrinter {
handler: &handler,
comments,
});
Err(())
})
.unwrap_err();
if output.trim().is_empty() {
panic!("Comments have incorrect position")
}
output.compare_to_file(output_file).unwrap();
}
struct CommentPrinter<'a> {
handler: &'a Handler,
comments: SingleThreadedComments,
}
impl Visit for CommentPrinter<'_> {
fn visit_span(&mut self, n: &Span) {
self.comments.with_leading(n.lo, |comments| {
for c in comments {
DiagnosticBuilder::new(
self.handler,
swc_common::errors::Level::Note,
"Leading (lo)",
)
.span_note(Span::new(n.lo, n.lo), &c.text)
.emit();
}
});
self.comments.with_trailing(n.lo, |comments| {
for c in comments {
DiagnosticBuilder::new(
self.handler,
swc_common::errors::Level::Note,
"Trailing (lo)",
)
.span_note(Span::new(n.lo, n.lo), &c.text)
.emit();
}
});
self.comments.with_leading(n.hi - BytePos(1), |comments| {
for c in comments {
DiagnosticBuilder::new(
self.handler,
swc_common::errors::Level::Note,
"Leading (hi)",
)
.span_note(Span::new(n.hi - BytePos(1), n.hi - BytePos(1)), &c.text)
.emit();
}
});
self.comments.with_trailing(n.hi, |comments| {
for c in comments {
DiagnosticBuilder::new(
self.handler,
swc_common::errors::Level::Note,
"Trailing (hi)",
)
.span_note(Span::new(n.hi, n.hi), &c.text)
.emit();
}
});
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/exprs/array/blockStmt/input.js | JavaScript | React.useEffect(() => {
// @refresh reset
}); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/exprs/call/simple/input.js | JavaScript | test(123/*post: 9*/, 456/*post: 10*/);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/exprs/paren-annotations/1/input.js | JavaScript | const fnB = /*#__NO_SIDE_EFFECTS__*/ (args) => {
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/exprs/paren-pure/1/input.js | JavaScript | /*#__PURE__*/ (console.log('simple'))
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/exprs/paren-pure/2/input.js | JavaScript |
/*#__PURE__*/((() => import('./any'))())
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/exprs/paren-pure/3/input.js | JavaScript | /*#__PURE__*/(((() => import('./any'))()))
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/issue-3715/input.js | JavaScript | a() /* IMPORTANT_DO_NOT_REMOVE */;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/issue-4876/input.js | JavaScript | /*!
something v5.1.0
more
else
*/
// a
console.log(1);
// b | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/stmts/block/input.js | JavaScript | while (1) {
/* test */
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/comments/stmts/switch/input.js | JavaScript | switch (1) {
case 2:
3;
// 4
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/common/mod.rs | Rust | use swc_common::Span;
use swc_ecma_ast::*;
use swc_ecma_visit::{Fold, FoldWith};
pub struct Normalizer {
pub drop_span: bool,
pub is_test262: bool,
}
impl Fold for Normalizer {
fn fold_class_members(&mut self, mut node: Vec<ClassMember>) -> Vec<ClassMember> {
node = node.fold_children_with(self);
if !self.is_test262 {
return node;
}
node.retain(|v| !matches!(v, ClassMember::Empty(..)));
node
}
fn fold_expr(&mut self, e: Expr) -> Expr {
let e = e.fold_children_with(self);
match e {
Expr::Paren(ParenExpr { expr, .. }) if self.is_test262 => *expr,
Expr::New(n @ NewExpr { args: None, .. }) if self.is_test262 => NewExpr {
args: Some(Vec::new()),
..n
}
.into(),
// Flatten comma expressions.
Expr::Seq(SeqExpr { mut exprs, span }) => {
let need_work = exprs.iter().any(|n| matches!(**n, Expr::Seq(..)));
if need_work {
exprs = exprs.into_iter().fold(Vec::new(), |mut v, e| {
match *e {
Expr::Seq(SeqExpr { exprs, .. }) => v.extend(exprs),
_ => v.push(e),
}
v
});
}
SeqExpr { exprs, span }.into()
}
_ => e,
}
}
fn fold_number(&mut self, n: Number) -> Number {
let mut n = n.fold_children_with(self);
let val = serde_json::Number::from_f64(n.value);
let val = match val {
Some(v) => v,
None => {
if self.is_test262 {
n.raw = None;
}
return n;
}
};
match val.as_f64() {
Some(value) => {
if self.is_test262 {
Number {
value,
raw: None,
..n
}
} else {
Number { value, ..n }
}
}
None => n,
}
}
fn fold_pat(&mut self, mut node: Pat) -> Pat {
node = node.fold_children_with(self);
if let Pat::Expr(expr) = node {
match *expr {
Expr::Ident(i) => return i.into(),
_ => {
node = expr.into();
}
}
}
node
}
fn fold_prop_name(&mut self, n: PropName) -> PropName {
let n = n.fold_children_with(self);
if !self.is_test262 {
return n;
}
match n {
PropName::Ident(IdentName { span, sym, .. }) => PropName::Str(Str {
span,
value: sym,
raw: None,
}),
PropName::Num(num) => PropName::Str(Str {
span: num.span,
value: num.to_string().into(),
raw: None,
}),
_ => n,
}
}
fn fold_span(&mut self, span: Span) -> Span {
if self.drop_span {
Span::default()
} else {
span
}
}
fn fold_str(&mut self, s: Str) -> Str {
let span = s.span.fold_with(self);
if self.is_test262 {
Str {
span,
value: s.value,
raw: None,
}
} else {
Str { span, ..s }
}
}
fn fold_simple_assign_target(&mut self, n: SimpleAssignTarget) -> SimpleAssignTarget {
let n = n.fold_children_with(self);
if self.is_test262 {
match n {
SimpleAssignTarget::Paren(ParenExpr { expr, .. }) => {
SimpleAssignTarget::try_from(expr).unwrap()
}
_ => n,
}
} else {
n
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors.rs | Rust | #![allow(unused)]
use std::{
fs::read_to_string,
path::{Path, PathBuf},
};
use pretty_assertions::assert_eq;
use swc_common::{errors::Handler, sync::Lrc, SourceMap};
use swc_ecma_ast::*;
use swc_ecma_parser::{lexer::Lexer, PResult, Parser, StringInput};
use swc_ecma_visit::{Fold, FoldWith};
use testing::{run_test, StdErr};
fn parse_module(cm: Lrc<SourceMap>, handler: &Handler, file_name: &Path) -> Result<Module, ()> {
with_parser(cm, handler, file_name, |p| p.parse_module())
}
fn with_parser<F, Ret>(
cm: Lrc<SourceMap>,
handler: &Handler,
file_name: &Path,
f: F,
) -> Result<Ret, ()>
where
F: FnOnce(&mut Parser<Lexer>) -> PResult<Ret>,
{
let fm = cm
.load_file(file_name)
.unwrap_or_else(|e| panic!("failed to load {}: {}", file_name.display(), e));
let is_ts = file_name
.extension()
.map(|ext| ext == "ts" || ext == "tsx")
.unwrap_or_default();
let is_jsx = file_name
.extension()
.map(|ext| ext == "jsx" || ext == "tsx")
.unwrap_or_default();
let syntax = if is_ts {
::swc_ecma_parser::Syntax::Typescript(::swc_ecma_parser::TsSyntax {
tsx: is_jsx,
..Default::default()
})
} else {
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: is_jsx,
explicit_resource_management: true,
..Default::default()
})
};
let mut p = Parser::new(syntax, (&*fm).into(), None);
let res = f(&mut p).map_err(|e| e.into_diagnostic(handler).emit());
for e in p.take_errors() {
e.into_diagnostic(handler).emit();
}
res
}
#[cfg(feature = "verify")]
#[testing::fixture("tests/errors/**/*.js")]
#[testing::fixture("tests/errors/**/*.mjs")]
#[testing::fixture("tests/errors/**/*.ts")]
#[testing::fixture("tests/errors/**/*.tsx")]
fn error(entry: PathBuf) {
let input = read_to_string(&entry).unwrap();
eprintln!(
"\n\n========== Running error reporting test \nSource:\n{}\n",
input
);
let err = run_test(false, |cm, handler| {
if false {
// Type annotation
return Ok(());
}
// Parse source
let _ = parse_module(cm, handler, &entry);
if !handler.has_errors() {
panic!("should emit error, but parsed without error")
}
Err(())
})
.expect_err("should fail, but parsed as");
if err
.compare_to_file(format!("{}.swc-stderr", entry.display()))
.is_err()
{
panic!()
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/arguments/input.js | JavaScript | class A {
static {
class B {
[arguments]
}
}
foo = arguments
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/arrow-function-binding-rest-property/input.js | JavaScript | ({...a.b})=>{};
(a, {...b.c})=>{};
(...{...{}})=>{};
(a, ...{...{}})=>{};
([...{...[]}])=>{};
(a, [...{...[]}])=>{}; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/arrow-function-member-as-binding-identifier/input.js | JavaScript | ({a: b.c })=>{};
([a.b])=>{};
(a.b)=>{};
(_, {a: b.c })=>{};
(_, [a.b])=>{};
(_, a.b)=>{};
(...a.b)=>{};
([...a.b])=>{};
({...a.b})=>{};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/async-line-break/1/input.js | JavaScript | foo = async
() => 42
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/async-line-break/2/input.js | JavaScript | foo = async
function() {
return 42
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence/input.js | JavaScript | const string = "\xZZ";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence_1/input.js | JavaScript | const string = "\x";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence_2/input.js | JavaScript | const string = "\uZZZZ";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence_3/input.js | JavaScript | const string = "\u{FFFFFF}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence_4/input.js | JavaScript | const string = "\xFZ";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence_5/input.js | JavaScript | const string = "\u{ZZZZ}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/bad_character_escape_sequence_6/input.js | JavaScript | const string = "\u{FFFFFF}";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/conflict_marker_diff_3_trivia_1/input.ts | TypeScript | class C {
<<<<<<< HEAD
v = 1;
||||||| merged common ancestors
v = 3;
=======
v = 2;
>>>>>>> Branch-a
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/conflict_marker_diff_3_trivia_2/input.ts | TypeScript | class C {
foo() {
<<<<<<< B
a();
}
||||||| merged common ancestors
c();
}
=======
b();
}
>>>>>>> A
public bar() { }
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/conflict_marker_trivia_1/input.ts | TypeScript | class C {
<<<<<<< HEAD
v = 1;
=======
v = 2;
>>>>>>> Branch-a
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/conflict_marker_trivia_2/input.ts | TypeScript | class C {
foo() {
<<<<<<< B
a();
}
=======
b();
}
>>>>>>> A
public bar() { }
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/conflict_marker_trivia_3/input.tsx | TypeScript (TSX) | const x = <div/>;
<<<<<<< HEAD | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/conflict_marker_trivia_4/input.ts | TypeScript | const x = <div>
<<<<<<< HEAD | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/.invalid-for-await-using-binding-of-of/input.mjs | JavaScript | for await (using of of of);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/.invalid-for-using-binding-of-of/input.js | JavaScript | for (using of of of);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-duplicate-using-bindings/input.js | JavaScript | {
using f, f = foo();
}
{
using g = foo();
using g = foo();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-for-using-binding-in/input.js | JavaScript | for (using foo in {});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-for-using-binding-of-in/input.js | JavaScript | for (using of in []);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-in-single-statement-context/input.js | JavaScript | {
while (1) using a;
for (;;) using b;
do using c; while (1);
if (1) using d;
with (1) using e;
label: using f;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-labeled-using-binding/input.js | JavaScript | {
label: using x = bar();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-script-top-level-labeled-using-binding/input.js | JavaScript | label: using x = bar();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-script-top-level-using-binding/.input.js | JavaScript | using x = bar();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-using-binding-await-module/input.js | JavaScript | {
using await = h();
}
{
using \u0061wait = h();
}
{
using x, await = h();
}
{
for (using await of []);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-using-binding-await-script/input.js | JavaScript | {
using await = h();
}
{
using \u0061wait = h();
}
{
using x, await = h();
}
{
for (using await of []);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-using-binding-let/input.js | JavaScript | {
using let = h();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-using-binding-pattern-declaration/input.js | JavaScript | {
using { foo } = f();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/explicit-resource-management/invalid-using-binding-pattern-for-lhs/input.js | JavaScript | {
for (using { qux } of h());
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-2834/input.js | JavaScript | ([(a)]) => {};
({ a: (b) }) => {};
for (const [(a)] of arr) {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-4991/1/input.js | JavaScript | const str = "meta";
console.log(import[str]); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-4991/2/input.js | JavaScript | console.log(import?.[meta]); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-4991/3/input.js | JavaScript | console.log(import?.meta); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-4991/4/input.js | JavaScript | console.log(import.[meta]); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-8268/1/input.js | JavaScript | export { default }
export { if }
export { default as foo }
export { if as bar }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-8268/2/input.ts | TypeScript | export { type export }
export { type if }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-8269/input.js | JavaScript | {
let let
}
{
const let = 0
}
{
class let { }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/issue-8687/input.ts | TypeScript | class Foo {
private #p1() { }
private #p2: number;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/jsx_in_js/input.js | JavaScript | const a = (
<section>
<a href="/foo">foo</a>
</section>
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/label/input.js | JavaScript | "use strict"
a: function b() {} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/optional-chaining/tagged-template.js | JavaScript | a?.b``
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/rest-initializer/input.js | JavaScript | [...a=1]=[];
[a,...b=1]=[];
([...a=1])=>{};
([a,...b=1])=>{};
({...a=1}={});
({a,...b=1}={});
({...a=1})=>{};
({a,...b=1})=>{};
(...a=1)=>{};
(a,...b=1)=>{};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/rest-not-last/input.js | JavaScript | [...a, b] = [...spread];
const [...a, b] = [...spread];
([...a, b]) => {};
({ ...a, b }) => {};
(...a, b) => {};
class c {
constructor(...a, b) {}
fn(...a, b) {}
}
function fn([...a, b]) {}
function fn({ ...a, b }) {}
function fn(...a, b) {}
({ ...a, b } = { ...spread });
const { ...a, b } = { ...spread };
for ([...a,b,] of a) {}
for ({...a,b,} of b) {} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/rest-trailing-comma/input.js | JavaScript | [...a,]=[...spread,];
const [...a,] = [...spread,];
([...a,],)=>{};
({...a,},)=>{};
(...a,)=>{};
class c {
constructor(...a,){}
fn(...a,) {}
}
function fn([...a,],) {};
function fn({...a,},) {};
function fn(...a,) {};
({...a,}={...spread,});
const {...a,} = {...spread,};
for ([...a,] of a) {}
for ({...a,} of b) {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/strict-mode/argument/input.js | JavaScript | export function f0() {
return Array.from(arguments, arguments => arguments + 1, (arguments, b) => arguments + b);
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/ts1106/input.js | JavaScript | let async;
for (async of [1]) ; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/unterminated_string_constant/input.js | JavaScript | const string = "\ | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/errors/unterminated_string_constant_1/input.js | JavaScript | const string = "\" | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js.rs | Rust | #![allow(clippy::needless_update)]
use std::{
fs::File,
io::Read,
path::{Path, PathBuf},
};
use swc_common::{comments::SingleThreadedComments, FileName};
use swc_ecma_ast::*;
use swc_ecma_parser::{lexer::Lexer, EsSyntax, PResult, Parser, Syntax};
use swc_ecma_visit::FoldWith;
use testing::StdErr;
use crate::common::Normalizer;
#[path = "common/mod.rs"]
mod common;
#[testing::fixture("tests/js/**/*.js")]
fn spec(file: PathBuf) {
let output = file.parent().unwrap().join(format!(
"{}.json",
file.file_name().unwrap().to_string_lossy()
));
run_spec(&file, &output);
}
fn run_spec(file: &Path, output_json: &Path) {
let file_name = file
.display()
.to_string()
.replace("\\\\", "/")
.replace('\\', "/");
{
// Drop to reduce memory usage.
//
// Because the test suite contains lots of test cases, it results in oom in
// github actions.
let input = {
let mut buf = String::new();
File::open(file).unwrap().read_to_string(&mut buf).unwrap();
buf
};
eprintln!(
"\n\n========== Running reference test {}\nSource:\n{}\n",
file_name, input
);
}
with_parser(false, file, false, |p, _| {
let program = p.parse_program()?.fold_with(&mut Normalizer {
drop_span: false,
is_test262: false,
});
let json =
serde_json::to_string_pretty(&program).expect("failed to serialize module as json");
if StdErr::from(json).compare_to_file(output_json).is_err() {
panic!()
}
Ok(())
})
.map_err(|_| ())
.unwrap();
}
fn with_parser<F, Ret>(
treat_error_as_bug: bool,
file_name: &Path,
shift: bool,
f: F,
) -> Result<Ret, StdErr>
where
F: FnOnce(&mut Parser<Lexer>, &SingleThreadedComments) -> PResult<Ret>,
{
::testing::run_test(treat_error_as_bug, |cm, handler| {
if shift {
cm.new_source_file(FileName::Anon.into(), "".into());
}
let comments = SingleThreadedComments::default();
let fm = cm
.load_file(file_name)
.unwrap_or_else(|e| panic!("failed to load {}: {}", file_name.display(), e));
let lexer = Lexer::new(
Syntax::Es(EsSyntax {
explicit_resource_management: true,
import_attributes: true,
decorators: true,
..Default::default()
}),
EsVersion::Es2015,
(&*fm).into(),
Some(&comments),
);
let mut p = Parser::new_from(lexer);
let res = f(&mut p, &comments).map_err(|e| e.into_diagnostic(handler).emit());
for err in p.take_errors() {
err.into_diagnostic(handler).emit();
}
if handler.has_errors() {
return Err(());
}
res
})
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/.attributes-expression/input.js | JavaScript | import.defer("x", { with: { attr: "val" } });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/.dynamic-import-no-createImportExpressions/input.js | JavaScript | import.defer("foo"); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/.dynamic-import/input.js | JavaScript | import.defer("foo"); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/attributes-declaration/input.js | JavaScript | import defer * as ns from "x" with { attr: "val" }; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/import-defer/input.js | JavaScript | import defer * as ns from "x";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/no-default/input.js | JavaScript | import defer x from "x";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/deferred-import-evaluation/no-named/input.js | JavaScript | import defer { x } from "x";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/explicit-resource-management/.valid-for-using-binding-escaped-of-of/input.js | JavaScript | for (using o\u0066 of of);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/explicit-resource-management/valid-for-await-using-binding-escaped-of-of/input.mjs | JavaScript | for await (using \u006ff of of);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/explicit-resource-management/valid-using-as-identifier-callee/input.js | JavaScript | using (x);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/explicit-resource-management/valid-using-as-identifier-computed-member-no-plugin/input.js | JavaScript | using [x] = 0;
for (using [x] of []);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/explicit-resource-management/valid-using-as-identifier-computed-member/input.js | JavaScript | using [x] = 0;
for (using [x] of []);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_parser/tests/js/explicit-resource-management/valid-using-as-identifier-expression-statement/input.js | JavaScript | using
reader = getReader()
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.