1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
//! RESSA (Rusty ECMAScript Syntax Analyzer)
//! A library for parsing js files
//!
//! The main interface for this library would be
//! the `Parser` iterator. A parser is constructed
//! either via the `::new()` function or a `Builder`.
//! As part of the constructor, you have to provide
//! the js you want to parse as an `&str`.
//!
//! Once constructed the parser will return a
//! `ProgramPart` for each iteration.
//!
//! A very simple example might look like this
//! ```
//! use ressa::Parser;
//! use resast::prelude::*;
//! fn main() {
//! let js = "function helloWorld() { alert('Hello world'); }";
//! let p = Parser::new(&js).unwrap();
//! let f = ProgramPart::decl(
//! Decl::Func(
//! Func {
//! id: Some(Ident::from("helloWorld")),
//! params: Vec::new(),
//! body: FuncBody(
//! vec![
//! ProgramPart::Stmt(
//! Stmt::Expr(
//! Expr::Call(
//! CallExpr {
//! callee: Box::new(
//! Expr::ident_from("alert")
//! ),
//! arguments: vec![
//! Expr::Lit(
//! Lit::single_string_from("Hello world")
//! )
//! ],
//! }
//! )
//! )
//! )
//! ]
//! ),
//! generator: false,
//! is_async: false,
//! }
//! )
//! );
//! for part in p {
//! // assert_eq!(part.unwrap(), f);
//! }
//! }
//!```
//! checkout the `examples` folders for slightly larger
//! examples.
//!
extern crate ress;
#[macro_use]
extern crate log;
extern crate backtrace;
use ress::prelude::*;
pub use ress::Span;
mod comment_handler;
mod error;
mod formal_params;
mod lexical_names;
mod lhs;
mod regex;
pub mod spanned;
pub use crate::comment_handler::CommentHandler;
pub use crate::comment_handler::DefaultCommentHandler;
pub use crate::error::Error;
use resast::prelude::*;
use std::collections::HashMap;
/// The current configuration options.
/// This will most likely increase over time
struct Config {
/// whether or not to tolerate a subset of errors
tolerant: bool,
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum LabelKind {
Iteration,
Other,
Unknown,
}
/// The current parsing context.
/// This structure holds the relevant
/// information to know when some
/// text might behave differently
/// depending on what has come before it
struct Context<'a> {
/// If the current JS should be treated
/// as a JS module
is_module: bool,
/// If `in` is allowed as an identifier
allow_in: bool,
/// If a strict directive is allowed
allow_strict_directive: bool,
/// If `yield` is allowed as an identifier
allow_yield: bool,
/// If await is allowed as an identifier
allow_await: bool,
/// if super is allowed as a keyword
allow_super: bool,
/// if super is allowed to be part of a call expression
/// allow_super should always be true when this is true
/// but not the other way around. This is only valid in a
/// constructor
allow_super_call: bool,
/// If we have found any possible naming errors
/// which are not yet resolved
first_covert_initialized_name_error: Option<Item<&'a str>>,
/// If the current expressions is an assignment target
is_assignment_target: bool,
/// If the current expression is a binding element
is_binding_element: bool,
/// If we have entered a function body
in_function_body: bool,
/// If we have entered a loop block
in_iteration: bool,
/// If we have entered a switch block
in_switch: bool,
/// The currently known labels, this applies
/// to labels only, not all identifiers. Errors
/// at that level would need to be handled by
/// the calling scope
label_set: HashMap<&'a str, LabelKind>,
/// If the current scope has a `'use strict';` directive
/// in the prelude
strict: bool,
lexical_names: lexical_names::DuplicateNameDetector<'a>,
/// If the scanner has a pending line terminator
/// before the next token
has_line_term: bool,
/// If we have passed the initial prelude where a valid
/// `'use strict'` directive would exist
past_prolog: bool,
/// If we encounter an error, the iterator should stop
errored: bool,
/// If we find a directive with an octal escape
/// we need to error if a 'use strict' directive
/// is then found
found_directive_octal_escape: bool,
}
impl Default for Config {
fn default() -> Self {
trace!("default config");
Self { tolerant: false }
}
}
impl<'a> Default for Context<'a> {
fn default() -> Self {
trace!("default context",);
Self {
is_module: false,
allow_await: true,
allow_in: true,
allow_strict_directive: true,
allow_yield: true,
allow_super: false,
allow_super_call: false,
first_covert_initialized_name_error: None,
is_assignment_target: false,
is_binding_element: false,
in_function_body: false,
in_iteration: false,
in_switch: false,
label_set: HashMap::new(),
strict: false,
lexical_names: lexical_names::DuplicateNameDetector::default(),
has_line_term: false,
past_prolog: false,
errored: false,
found_directive_octal_escape: false,
}
}
}
impl<'a> Context<'a> {
pub fn set_allow_super(&mut self, value: bool) {
trace!("context.set_allow_super({})", value);
self.allow_super = value;
}
pub fn set_is_assignment_target(&mut self, value: bool) -> bool {
trace!(
"context.set_is_assignment_target({}) -> {}",
value,
self.is_assignment_target
);
let old = self.is_assignment_target;
self.is_assignment_target = value;
old
}
pub fn set_is_binding_element(&mut self, value: bool) -> bool {
trace!(
"context.set_is_binding_element({}) -> {}",
value,
self.is_binding_element
);
let old = self.is_binding_element;
self.is_binding_element = value;
old
}
}
/// This is used to create a `Parser` using
/// the builder method
#[derive(Default)]
pub struct Builder<'b> {
inner: crate::spanned::Builder<'b>,
}
impl<'b> Builder<'b> {
pub fn new() -> Self {
Self::default()
}
/// Enable or disable error tolerance
/// default: `false`
pub fn set_tolerant(&mut self, value: bool) {
self.inner.set_tolerant(value);
}
/// Enable or disable error tolerance with a builder
/// pattern
/// default: `false`
pub fn tolerant(mut self, value: bool) -> Self {
self.set_tolerant(value);
self
}
/// Set the parsing context to module or script
/// default: `false` (script)
pub fn set_module(&mut self, value: bool) {
self.inner.set_module(value);
}
/// Set the parsing context to module or script
/// with a builder pattern
/// default: `false` (script)
pub fn module(mut self, value: bool) -> Self {
self.set_module(value);
self
}
/// Set the js text that this parser would operate
/// on
pub fn set_js(&mut self, js: &'b str) {
self.inner.set_js(js);
}
/// Set the js text that this parser would operate
/// on with a builder pattern
pub fn js(mut self, js: &'b str) -> Self {
self.set_js(js);
self
}
/// Complete the builder pattern returning
/// `Result<Parser, Error>`
pub fn build(self) -> Res<Parser<'b, DefaultCommentHandler>> {
let inner = self.inner.build()?;
Ok(Parser { inner })
}
}
impl<'b> Builder<'b> {
pub fn with_comment_handler<CH>(self, handler: CH) -> Res<Parser<'b, CH>>
where
CH: CommentHandler<'b>,
{
let inner = self.inner.with_comment_handler(handler)?;
Ok(Parser { inner })
}
}
/// This is the primary interface that you would interact with.
/// There are two main ways to use it, the first is to utilize
/// the `Iterator` implementation. Each iteration will return
/// a `Result<ProgramPart, Error>`.
/// The other option is to use the `parse` method, which is just
/// a wrapper around the `collect` method on `Iterator`, however
/// the final result will be a `Result<Program, Error>` and the
/// `ProgramPart` collection will be the inner data. Since modern
/// js allows for both `Module`s as well as `Script`s, these will be
/// the two `enum` variants.
pub struct Parser<'a, CH> {
inner: crate::spanned::Parser<'a, CH>,
}
/// The start/end index of a line
#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
pub struct Line {
start: usize,
end: usize,
}
/// The result type for the Parser operations
type Res<T> = Result<T, Error>;
impl<'a> Parser<'a, DefaultCommentHandler> {
/// Create a new parser with the provided
/// javascript
/// This will default to parsing in the
/// script context and discard comments.
/// If you wanted change this behavior
/// utilize the `Builder` pattern
pub fn new(text: &'a str) -> Res<Self> {
let inner = crate::spanned::Parser::new(text)?;
Ok(Self { inner })
}
}
impl<'a> Parser<'a, ()> {
pub fn builder() -> Builder<'a> {
Builder::new()
}
}
impl<'b, CH> Parser<'b, CH>
where
CH: CommentHandler<'b> + Sized,
{
/// Wrapper around the `Iterator` implementation for
/// Parser
/// ```
/// extern crate ressa;
/// use ressa::Parser;
/// use resast::prelude::*;
/// fn main() {
/// let js = "function helloWorld() { alert('Hello world'); }";
/// let mut p = Parser::new(&js).unwrap();
/// let call = CallExpr {
/// callee: Box::new(Expr::ident_from("alert")),
/// arguments: vec![Expr::Lit(Lit::single_string_from("Hello world"))],
/// };
/// let expectation = Program::Script(vec![ProgramPart::Decl(Decl::Func(Func {
/// id: Some(Ident::from("helloWorld")),
/// params: Vec::new(),
/// body: FuncBody(vec![ProgramPart::Stmt(Stmt::Expr(Expr::Call(call)))]),
/// generator: false,
/// is_async: false,
/// }))]);
/// let program = p.parse().unwrap();
/// //assert_eq!(program, expectation);
/// }
/// ```
pub fn parse(&mut self) -> Res<Program> {
let ret = self.inner.parse()?;
Ok(ret.into())
}
pub fn next_position(&self) -> SourceLocation {
self.inner.next_position()
}
pub fn comment_handler(&self) -> &CH {
&self.inner.comment_handler
}
pub fn comment_handler_mut(&mut self) -> &mut CH {
&mut self.inner.comment_handler
}
}
impl<'b, CH> Iterator for Parser<'b, CH>
where
CH: CommentHandler<'b> + Sized,
{
type Item = Res<ProgramPart<'b>>;
fn next(&mut self) -> Option<Self::Item> {
let ret = self.inner.next()?;
Some(ret.map(Into::into))
}
}