feat(es/parser): Support stripping flow with ES parser

crates/swc_ecma_parser/Cargo.toml

@@ -18,8 +18,10 @@ bench = false
 
 [features]
 # Used for debugging
-debug = ["tracing-spans"]
-default = ["typescript", "stacker"]
+debug = ["tracing-spans"]
+default = ["typescript", "stacker"]
+# Strip flow types
+flow = []
 tracing-spans = []
 typescript = []
 verify = ["swc_ecma_visit"]

crates/swc_ecma_parser/src/error.rs

@@ -292,6 +292,25 @@ pub enum SyntaxError {
 
  ReservedTypeAssertion,
  ReservedArrowTypeParam,
+
+ FlowThisParamMustBeFirst,
+ FlowThisParamCannotBeOptional,
+ FlowReservedWordInType {
+ word: JsWord,
+ },
+ FlowInexactInsideNonObject,
+ FlowInexactInsideExact,
+ FlowInexactVariance,
+ FlowUnexpectedSpreadType,
+ FlowUnexpectedProtoSpread,
+ FlowSpreadVariance,
+ FlowUnexpectedProtoMethod,
+ FlowMethodVariance,
+ FlowUnexpectedGetterSetter,
+ FlowDeclareOpaqueType,
+ FlowEnumExplicitTypeMustBeIdent,
+ FlowEnumInitMustBeLiteral,
+ FlowEnumShouldHaveMember,
 }
 
 impl SyntaxError {
@@ -758,6 +777,38 @@ impl SyntaxError {
  as in `<T,>() => ...`."
  .into(),
  SyntaxError::InvalidAssignTarget => "Invalid assignment target".into(),
+ SyntaxError::FlowThisParamMustBeFirst => {
+ "The 'this' parameter must be the first parameter".into()
+ }
+ SyntaxError::FlowThisParamCannotBeOptional => {
+ "The 'this' parameter cannot be optional".into()
+ }
+ SyntaxError::FlowReservedWordInType { ref word } => {
+ format!("Cannot use a reserved word as a type name: '{}'", word).into()
+ }
+ SyntaxError::FlowInexactInsideNonObject => {
+ "Inexact type can only be used with object type".into()
+ }
+ SyntaxError::FlowInexactInsideExact => {
+ "Exact type can only be used with object type".into()
+ }
+ SyntaxError::FlowInexactVariance => "Inexact type cannot have variance".into(),
+ SyntaxError::FlowUnexpectedSpreadType => "Unexpected spread type".into(),
+ SyntaxError::FlowUnexpectedProtoSpread => {
+ "Unexpected spread of prototype property".into()
+ }
+ SyntaxError::FlowSpreadVariance => "Spread type cannot have variance".into(),
+ SyntaxError::FlowUnexpectedProtoMethod => "Unexpected prototype method".into(),
+ SyntaxError::FlowMethodVariance => "Method cannot have variance".into(),
+ SyntaxError::FlowUnexpectedGetterSetter => {
+ "Unexpected getter or setter in object type".into()
+ }
+ SyntaxError::FlowDeclareOpaqueType => "Opaque type cannot be declared".into(),
+ SyntaxError::FlowEnumExplicitTypeMustBeIdent => {
+ "Explicit type for enum must be an identifier".into()
+ }
+ SyntaxError::FlowEnumInitMustBeLiteral => "Enum initializer must be a literal".into(),
+ SyntaxError::FlowEnumShouldHaveMember => "Enum must have at least one member".into(),
  }
  }
 }

crates/swc_ecma_parser/src/lexer/table.rs

@@ -172,6 +172,8 @@ const L_L: ByteHandler = Some(|lexer| {
 const L_M: ByteHandler = Some(|lexer| {
  lexer.read_word_with(&|s| match s {
  "meta" => Some(Word::Ident(IdentLike::Known(KnownIdent::Meta))),
+ "mixins" => Some(Word::Ident(IdentLike::Known(KnownIdent::Mixins))),
+ "module" => Some(Word::Ident(IdentLike::Known(KnownIdent::Module))),
  _ => None,
  })
 });
@@ -191,6 +193,7 @@ const L_O: ByteHandler = Some(|lexer| {
  lexer.read_word_with(&|s| match s {
  "of" => Some(Word::Ident(IdentLike::Known(KnownIdent::Of))),
  "object" => Some(Word::Ident(IdentLike::Known(KnownIdent::Object))),
+ "opaque" => Some(Word::Ident(IdentLike::Known(KnownIdent::Opaque))),
  _ => None,
  })
 });
@@ -201,6 +204,7 @@ const L_P: ByteHandler = Some(|lexer| {
  "package" => Some(Word::Ident(IdentLike::Known(KnownIdent::Package))),
  "protected" => Some(Word::Ident(IdentLike::Known(KnownIdent::Protected))),
  "private" => Some(Word::Ident(IdentLike::Known(KnownIdent::Private))),
+ "proto" => Some(Word::Ident(IdentLike::Known(KnownIdent::Proto))),
  _ => None,
  })
 });
@@ -212,6 +216,7 @@ const L_R: ByteHandler = Some(|lexer| {
  "return" => Some(Word::Keyword(Keyword::Return)),
  "readonly" => Some(Word::Ident(IdentLike::Known(KnownIdent::Readonly))),
  "require" => Some(Word::Ident(IdentLike::Known(KnownIdent::Require))),
+ "renders" => Some(Word::Ident(IdentLike::Known(KnownIdent::Renders))),
  _ => None,
  })
 });

crates/swc_ecma_parser/src/lib.rs

@@ -116,7 +116,6 @@
 #![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)]
@@ -156,6 +155,11 @@ pub enum Syntax {
  #[cfg_attr(docsrs, doc(cfg(feature = "typescript")))]
  #[serde(rename = "typescript")]
  Typescript(TsSyntax),
+ /// This variant requires the cargo feature `flow` to be enabled.
+ #[cfg(feature = "flow")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "flow")))]
+ #[serde(rename = "flow")]
+ Flow(FlowSyntax),
 }
 
 impl Default for Syntax {
@@ -184,6 +188,8 @@ impl Syntax {
  }) => import_attributes,
  #[cfg(feature = "typescript")]
  Syntax::Typescript(_) => true,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => true,
  }
  }
 
@@ -193,6 +199,8 @@ impl Syntax {
  Syntax::Es(EsSyntax { jsx: true, .. }) => true,
  #[cfg(feature = "typescript")]
  Syntax::Typescript(TsSyntax { tsx: true, .. }) => true,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => true,
  _ => false,
  }
  }
@@ -210,6 +218,8 @@ impl Syntax {
  Syntax::Typescript(TsSyntax {
  decorators: true, ..
  }) => true,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => true,
  _ => false,
  }
  }
@@ -238,6 +248,18 @@ impl Syntax {
  matches!(self, Syntax::Typescript(..))
  }
 
+ /// Should we parse flow?
+ #[cfg(not(feature = "flow"))]
+ pub const fn flow(self) -> bool {
+ false
+ }
+
+ /// Should we parse flow?
+ #[cfg(feature = "flow")]
+ pub const fn flow(self) -> bool {
+ matches!(self, Syntax::Flow(..))
+ }
+
  pub fn export_default_from(self) -> bool {
  matches!(
  self,
@@ -264,6 +286,8 @@ impl Syntax {
  }) => allow_super_outside_method,
  #[cfg(feature = "typescript")]
  Syntax::Typescript(_) => true,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => false,
  }
  }
 
@@ -275,6 +299,8 @@ impl Syntax {
  }) => allow_return_outside_function,
  #[cfg(feature = "typescript")]
  Syntax::Typescript(_) => false,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => false,
  }
  }
 
@@ -283,6 +309,8 @@ impl Syntax {
  #[cfg(feature = "typescript")]
  Syntax::Typescript(t) => !t.no_early_errors,
  Syntax::Es(..) => true,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => true,
  }
  }
 
@@ -302,6 +330,8 @@ impl Syntax {
  }) => *using_decl,
  #[cfg(feature = "typescript")]
  Syntax::Typescript(_) => true,
+ #[cfg(feature = "flow")]
+ Syntax::Flow(..) => true,
  }
  }
 }
@@ -379,6 +409,10 @@ pub struct EsSyntax {
 #[deprecated(note = "Use 'EsSyntax' instead")]
 pub type EsConfig = EsSyntax;
 
+#[cfg(feature = "flow")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct FlowSyntax {}
+
 /// Syntactic context.
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Context {
@@ -442,6 +476,8 @@ pub struct Context {
  disallow_conditional_types: bool,
 
  allow_using_decl: bool,
+
+ flow_no_anon_function_type: bool,
 }
 
 #[derive(Debug, Clone, Copy, Default)]

crates/swc_ecma_parser/src/parser/class_and_fn.rs

@@ -92,6 +92,9 @@ impl<I: Tokens> Parser<I> {
 
  let type_params = if p.input.syntax().typescript() {
  p.try_parse_ts_type_params(true, true)?
+ } else if p.syntax().flow() {
+ p.may_consume_flow_type_param_decls()?;
+ None
  } else {
  None
  };
@@ -121,6 +124,9 @@ impl<I: Tokens> Parser<I> {
 
  let implements = if p.input.syntax().typescript() && eat!(p, "implements") {
  p.parse_ts_heritage_clause()?
+ } else if p.input.syntax().flow() && eat!(p, "implements") {
+ p.consume_flow_interface_extends()?;
+ vec![]
  } else {
  vec![]
  };
@@ -239,6 +245,10 @@ impl<I: Tokens> Parser<I> {
  // 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 if self.syntax().flow() && is!(self, '<') {
+ self.may_consume_flow_type_param_decls()?;
+
+ Ok((super_class, None))
  } else {
  Ok((super_class, None))
  }
@@ -382,7 +392,7 @@ impl<I: Tokens> Parser<I> {
 
  let start = cur_pos!(self);
  let decorators = self.parse_decorators(false)?;
- let declare = self.syntax().typescript() && eat!(self, "declare");
+ let declare = (self.syntax().typescript() || self.syntax().flow()) && eat!(self, "declare");
  let accessibility = if self.input.syntax().typescript() {
  self.parse_access_modifier()?
  } else {
@@ -1066,7 +1076,14 @@ impl<I: Tokens> Parser<I> {
  }
  let definite = self.input.syntax().typescript() && !is_optional && eat!(self, '!');
 
- let type_ann = self.try_parse_ts_type_ann()?;
+ let type_ann = if self.input.syntax().typescript() {
+ self.try_parse_ts_type_ann()?
+ } else if self.input.syntax().flow() {
+ self.may_consume_flow_type_ann()?;
+ None
+ } else {
+ None
+ };
 
  let ctx = Context {
  include_in_expr: true,
@@ -1150,12 +1167,14 @@ impl<I: Tokens> Parser<I> {
 
  fn is_class_method(&mut self) -> bool {
  is!(self, '(')
- || (self.input.syntax().typescript() && is!(self, '<'))
- || (self.input.syntax().typescript() && is!(self, JSXTagStart))
+ || ((self.input.syntax().typescript() || self.input.syntax().flow()) && is!(self, '<'))
+ || ((self.input.syntax().typescript() || self.input.syntax().flow())
+ && is!(self, JSXTagStart))
  }
 
  fn is_class_property(&mut self, asi: bool) -> bool {
  (self.input.syntax().typescript() && is!(self, '!' | ':'))
+ || (self.input.syntax().flow() && is!(self, ':'))
  || is!(self, '=' | '}')
  || if asi {
  is!(self, ';')
@@ -1298,6 +1317,9 @@ impl<I: Tokens> Parser<I> {
  None
  })
  })?
+ } else if p.syntax().flow() {
+ p.may_consume_flow_type_param_decls()?;
+ None
  } else {
  None
  };
@@ -1319,6 +1341,10 @@ impl<I: Tokens> Parser<I> {
  let return_type = if p.syntax().typescript() && is!(p, ':') {
  p.parse_ts_type_or_type_predicate_ann(&tok!(':'))
  .map(Some)?
+ } else if p.input.syntax().flow() && is!(p, ':') {
+ p.consume_flow_type_ann()?;
+
+ None
  } else {
  None
  };
@@ -1675,7 +1701,10 @@ impl<I: Tokens> FnBodyParser<Option<BlockStmt>> for Parser<I> {
  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, ';') {
+ if (self.input.syntax().typescript() || self.input.syntax().flow())
+ && !is!(self, '{')
+ && eat!(self, ';')
+ {
  return Ok(None);
  }
  let block = self.include_in_expr(true).parse_block(true);

crates/swc_ecma_parser/src/parser/expr.rs

@@ -615,6 +615,10 @@ impl<I: Tokens> Parser<I> {
  }
  Ok(Some(args))
  })
+ } else if self.input.syntax().flow() && is!(self, '<') {
+ self.consume_flow_type_param_decl()?;
+
+ None
  } else {
  None
  };
@@ -659,6 +663,9 @@ impl<I: Tokens> Parser<I> {
 
  let type_args = if self.syntax().typescript() && is!(self, '<') {
  self.try_parse_ts_type_args()
+ } else if self.syntax().flow() && is!(self, '<') {
+ self.consume_flow_type_parameter_instantiation_call_or_new()?;
+ None
  } else {
  None
  };
@@ -842,6 +849,12 @@ impl<I: Tokens> Parser<I> {
 
  Ok(Some(return_type))
  })
+ } else if !self.ctx().will_expect_colon_for_cond
+ && self.input.syntax().flow()
+ && is!(self, ':')
+ {
+ self.consume_flow_type_ann()?;
+ None
  } else {
  None
  };
@@ -1886,6 +1899,10 @@ impl<I: Tokens> Parser<I> {
 
  items.push(AssignTargetOrSpread::Pat(pat))
  } else {
+ if self.input.syntax().flow() && is!(self, ':') {
+ self.may_consume_flow_type_ann()?;
+ }
+
  if has_modifier {
  self.emit_err(span!(self, modifier_start), SyntaxError::TS2369);
  }