free parse_ts_type_ann

Author: bvanjoi

crates/swc_ecma_lexer/src/common/parser/pat.rs

@@ -643,7 +643,7 @@ pub fn parse_constructor_params<'a, P: Parser<'a>>(p: &mut P) -> PResult<Vec<Par
             let type_ann = if p.input().syntax().typescript() && p.input_mut().is(&P::Token::COLON)
             {
                 let cur_pos = p.cur_pos();
-                Some(parse_ts_type_ann(p, /* eat_colon */ true, cur_pos)?)
+                Some(parse_ts_type_ann(p, /* eat_colon */ true, cur_pos).map(Box::new)?)
             } else {
                 None
             };
@@ -708,7 +708,7 @@ pub fn parse_formal_params<'a, P: Parser<'a>>(p: &mut P) -> PResult<Vec<Param>>
             let type_ann = if p.input().syntax().typescript() && p.input_mut().is(&P::Token::COLON)
             {
                 let cur_pos = p.cur_pos();
-                let ty = parse_ts_type_ann(p, /* eat_colon */ true, cur_pos)?;
+                let ty = parse_ts_type_ann(p, /* eat_colon */ true, cur_pos).map(Box::new)?;
                 Some(ty)
             } else {
                 None

crates/swc_ecma_lexer/src/common/parser/typescript.rs

@@ -533,11 +533,11 @@ pub fn parse_ts_type_ref<'a, P: Parser<'a>>(p: &mut P) -> PResult<TsTypeRef> {
     feature = "tracing-spans",
     tracing::instrument(level = "debug", skip_all)
 )]
-pub fn parse_ts_type_ann<'a, P: Parser<'a>>(
+pub(super) fn parse_ts_type_ann<'a, P: Parser<'a>>(
     p: &mut P,
     eat_colon: bool,
     start: BytePos,
-) -> PResult<Box<TsTypeAnn>> {
+) -> PResult<TsTypeAnn> {
     trace_cur!(p, parse_ts_type_ann);
 
     debug_assert!(p.input().syntax().typescript());
@@ -551,10 +551,10 @@ pub fn parse_ts_type_ann<'a, P: Parser<'a>>(
 
         let type_ann = parse_ts_type(p)?;
 
-        Ok(Box::new(TsTypeAnn {
+        Ok(TsTypeAnn {
             span: p.span(start),
             type_ann,
-        }))
+        })
     })
 }
 
@@ -570,10 +570,10 @@ pub fn parse_ts_this_type_predicate<'a, P: Parser<'a>>(
     let param_name = TsThisTypeOrIdent::TsThisType(lhs);
     let type_ann = if p.input_mut().eat(&P::Token::IS) {
         let cur_pos = p.input_mut().cur_pos();
-        Some(parse_ts_type_ann(
+        Some(Box::new(parse_ts_type_ann(
             p, // eat_colon
             false, cur_pos,
-        )?)
+        )?))
     } else {
         None
     };
@@ -823,17 +823,21 @@ pub fn parse_ts_type_or_type_predicate_ann<'a, P: Parser<'a>>(
                 // eat_colon
                 false,
                 return_token_start,
-            );
+            )
+            .map(Box::new);
         }
 
         let type_pred_var = parse_ident_name(p)?;
         let type_ann = if has_type_pred_is {
             p.assert_and_bump(&P::Token::IS);
             let pos = p.input_mut().cur_pos();
-            Some(parse_ts_type_ann(
-                p, // eat_colon
-                false, pos,
-            )?)
+            Some(
+                parse_ts_type_ann(
+                    p, // eat_colon
+                    false, pos,
+                )
+                .map(Box::new)?,
+            )
         } else {
             None
         };
@@ -921,17 +925,19 @@ fn try_parse_ts_type<'a, P: Parser<'a>>(p: &mut P) -> PResult<Option<Box<TsType>
     feature = "tracing-spans",
     tracing::instrument(level = "debug", skip_all)
 )]
-pub fn try_parse_ts_type_ann<'a, P: Parser<'a>>(p: &mut P) -> PResult<Option<Box<TsTypeAnn>>> {
+pub(super) fn try_parse_ts_type_ann<'a, P: Parser<'a>>(
+    p: &mut P,
+) -> PResult<Option<Box<TsTypeAnn>>> {
     if !cfg!(feature = "typescript") {
         return Ok(None);
     }
 
     if p.input_mut().is(&P::Token::COLON) {
         let pos = p.cur_pos();
-        return parse_ts_type_ann(p, /* eat_colon */ true, pos).map(Some);
+        parse_ts_type_ann(p, /* eat_colon */ true, pos).map(|t| Some(Box::new(t)))
+    } else {
+        Ok(None)
     }
-
-    Ok(None)
 }
 
 /// `tsNextThenParseType`
@@ -1298,7 +1304,7 @@ pub fn try_parse_ts_index_signature<'a, P: Parser<'a>>(
 
     let type_ann = parse_ts_type_ann(p, /* eat_colon */ false, type_ann_start)?;
     id.span = p.span(ident_start);
-    id.type_ann = Some(type_ann);
+    id.type_ann = Some(Box::new(type_ann));
 
     expect!(p, &P::Token::RBRACKET);