1
- use std:: mem:: take;
1
+ use std:: { iter :: once , mem:: take} ;
2
2
3
- use swc_common:: { util:: take:: Take , Spanned , DUMMY_SP } ;
3
+ use swc_common:: { pass :: Either , util:: take:: Take , Spanned , DUMMY_SP } ;
4
4
use swc_ecma_ast:: * ;
5
5
use swc_ecma_usage_analyzer:: {
6
6
alias:: { collect_infects_from, AccessKind , AliasConfig } ,
@@ -565,61 +565,59 @@ impl Optimizer<'_> {
565
565
& mut self ,
566
566
s : & ' a mut Stmt ,
567
567
options : & CompressOptions ,
568
- ) -> Option < Vec < Mergable < ' a > > > {
568
+ ) -> Option < Either < impl Iterator < Item = Mergable < ' a > > , std :: iter :: Once < Mergable < ' a > > > > {
569
569
Some ( match s {
570
570
Stmt :: Expr ( e) => {
571
571
if self . options . sequences ( )
572
572
|| self . options . collapse_vars
573
573
|| self . options . side_effects
574
574
{
575
- vec ! [ Mergable :: Expr ( & mut e. expr) ]
575
+ Either :: Right ( once ( Mergable :: Expr ( & mut e. expr ) ) )
576
576
} else {
577
577
return None ;
578
578
}
579
579
}
580
580
Stmt :: Decl ( Decl :: Var ( v) ) => {
581
581
if options. reduce_vars || options. collapse_vars {
582
- v. decls . iter_mut ( ) . map ( Mergable :: Var ) . collect ( )
582
+ Either :: Left ( v. decls . iter_mut ( ) . map ( Mergable :: Var ) )
583
583
} else {
584
584
return None ;
585
585
}
586
586
}
587
587
Stmt :: Return ( ReturnStmt { arg : Some ( arg) , .. } ) => {
588
- vec ! [ Mergable :: Expr ( arg) ]
588
+ Either :: Right ( once ( Mergable :: Expr ( arg) ) )
589
589
}
590
590
591
- Stmt :: If ( s) if options. sequences ( ) => {
592
- vec ! [ Mergable :: Expr ( & mut s. test) ]
593
- }
591
+ Stmt :: If ( s) if options. sequences ( ) => Either :: Right ( once ( Mergable :: Expr ( & mut s. test ) ) ) ,
594
592
595
593
Stmt :: Switch ( s) if options. sequences ( ) => {
596
- vec ! [ Mergable :: Expr ( & mut s. discriminant) ]
594
+ Either :: Right ( once ( Mergable :: Expr ( & mut s. discriminant ) ) )
597
595
}
598
596
599
597
Stmt :: For ( s) if options. sequences ( ) => {
600
598
if let Some ( VarDeclOrExpr :: Expr ( e) ) = & mut s. init {
601
- vec ! [ Mergable :: Expr ( e) ]
599
+ Either :: Right ( once ( Mergable :: Expr ( e) ) )
602
600
} else {
603
601
return None ;
604
602
}
605
603
}
606
604
607
605
Stmt :: ForOf ( s) if options. sequences ( ) => {
608
- vec ! [ Mergable :: Expr ( & mut s. right) ]
606
+ Either :: Right ( once ( Mergable :: Expr ( & mut s. right ) ) )
609
607
}
610
608
611
609
Stmt :: ForIn ( s) if options. sequences ( ) => {
612
- vec ! [ Mergable :: Expr ( & mut s. right) ]
610
+ Either :: Right ( once ( Mergable :: Expr ( & mut s. right ) ) )
613
611
}
614
612
615
613
Stmt :: Throw ( s) if options. sequences ( ) => {
616
- vec ! [ Mergable :: Expr ( & mut s. arg) ]
614
+ Either :: Right ( once ( Mergable :: Expr ( & mut s. arg ) ) )
617
615
}
618
616
619
617
Stmt :: Decl ( Decl :: Fn ( f) ) => {
620
618
// Check for side effects
621
619
622
- vec ! [ Mergable :: FnDecl ( f) ]
620
+ Either :: Right ( once ( Mergable :: FnDecl ( f) ) )
623
621
}
624
622
625
623
_ => return None ,
@@ -646,12 +644,9 @@ impl Optimizer<'_> {
646
644
return ;
647
645
}
648
646
649
- let mut exprs = Vec :: new ( ) ;
650
- let mut buf = Vec :: new ( ) ;
651
-
652
- for stmt in stmts. iter_mut ( ) {
653
- let is_end = matches ! (
654
- stmt. as_stmt( ) ,
647
+ fn is_end ( s : Option < & Stmt > ) -> bool {
648
+ matches ! (
649
+ s,
655
650
Some (
656
651
Stmt :: If ( ..)
657
652
| Stmt :: Throw ( ..)
@@ -661,7 +656,14 @@ impl Optimizer<'_> {
661
656
| Stmt :: ForIn ( ..)
662
657
| Stmt :: ForOf ( ..)
663
658
) | None
664
- ) ;
659
+ )
660
+ }
661
+
662
+ let mut exprs = Vec :: new ( ) ;
663
+ let mut buf = Vec :: new ( ) ;
664
+
665
+ for stmt in stmts. iter_mut ( ) {
666
+ let is_end = is_end ( stmt. as_stmt ( ) ) ;
665
667
let can_skip = match stmt. as_stmt ( ) {
666
668
Some ( Stmt :: Decl ( Decl :: Fn ( ..) ) ) => true ,
667
669
_ => false ,
0 commit comments