Basical design work is done

Author: kdy1

ecmascript/optimizer/src/ast.rs

@@ -1,20 +1,67 @@
+use swc_common::Mark;
+use swc_common::Span;
+use swc_common::GLOBALS;
 use swc_ecma_ast::*;
 use swc_ecma_visit::noop_visit_mut_type;
 use swc_ecma_visit::VisitMut;
 use swc_ecma_visit::VisitMutWith;
 
 /// Make every statements `identifiable` by marking all spans.
 ///
-/// This requires [swc_common::GLOBALS] to be set.
+/// This requires [swc_common::GLOBALS] to be set and same instance of
+/// [swc_common::Globals] should be used for [prepare] and [clean].
 pub(crate) fn prepare(m: &mut Module) {
-    m.visit_mut_with(&mut Preparer)
+    debug_assert!(
+        GLOBALS.is_set(),
+        "swc_common::GLOBALS should be set before calling optimizer::ast::prepare"
+    );
+
+    m.visit_mut_with(&mut MarkModifier { remove_mode: false })
+}
+
+/// Make every statements `identifiable` by marking all spans.
+///
+/// This requires [swc_common::GLOBALS] to be set and same instance of
+/// [swc_common::Globals] should be used for [prepare] and [clean].
+pub(crate) fn clean_up(m: &mut Module) {
+    debug_assert!(
+        GLOBALS.is_set(),
+        "swc_common::GLOBALS should be set before calling optimizer::ast::clean_up"
+    );
+
+    m.visit_mut_with(&mut MarkModifier { remove_mode: true })
 }
 
-struct Preparer;
+/// This struct applies a mark to or remove the mark from all useful span nodes.
+///
+/// This is shared between marking process and removing process to ensure that
+/// we only remove marks applied by this pass.
+struct MarkModifier {
+    remove_mode: bool,
+}
 
-impl VisitMut for Preparer {
+impl VisitMut for MarkModifier {
     noop_visit_mut_type!();
 
+    fn visit_mut_span(&mut self, span: &mut Span) {
+        if self.remove_mode {
+            let mark = span.remove_mark();
+            debug_assert_eq!(
+                mark.parent(),
+                Mark::root(),
+                "optimizer::ast::clean_up should be only called for prepared modules, which is \
+                 created by calling optimizer::ast::prepare"
+            );
+        } else {
+            let mark = Mark::fresh(Mark::root());
+            *span = span.apply_mark(mark);
+        }
+    }
+
+    /// Noop. This is required for correctness, as simply marking everything
+    /// breaks span hygiene.
+    fn visit_mut_ident(&mut self, _: &mut Ident) {}
+
     /// Noop. This is performance optimization.
     fn visit_mut_lit(&mut self, _: &mut Lit) {}
 }

ecmascript/optimizer/src/control_flow_graph/mod.rs

@@ -6,13 +6,20 @@ use crate::block_id::BlockId;
 use crate::block_id::BlockIdGenerator;
 use crate::mutations::Mutations;
 use fxhash::FxHashMap;
+use petgraph::graphmap::DiGraphMap;
 use std::cell::RefCell;
 use std::mem::take;
 use std::rc::Rc;
 use swc_ecma_ast::*;
 use swc_ecma_utils::Id;
 
-pub mod traversal;
+pub(crate) mod traversal;
+
+/// Actual `control flow` part of the control flow graph.
+///
+/// This type is used instead of hashmap to reduce work related to implementing
+/// visitors/
+pub(crate) type BlockGraph<'cfg> = DiGraphMap<BlockId, Vec<JumpCond<'cfg>>>;
 
 /// This struct is required for optimizaiotn.
 #[derive(Debug)]
@@ -21,7 +28,7 @@ pub struct ControlFlowGraph<'cfg> {
 
     blocks: FxHashMap<BlockId, Block<'cfg>>,
 
-    next: FxHashMap<BlockId, Vec<(BlockId, JumpCond<'cfg>)>>,
+    next: BlockGraph<'cfg>,
     start: BlockId,
 
     exprs: Vec<ExprData<'cfg>>,
@@ -69,17 +76,11 @@ impl<'cfg> ControlFlowGraph<'cfg> {
             mutations: Default::default(),
         }
     }
-
-    pub fn apply(self, to: &mut Module) {
-        assert_eq!(to.body.len(), self.module_items.len());
-
-        self.mutations.apply(to);
-    }
 }
 #[derive(Debug)]
 struct Analyzer<'cfg, 'a> {
     blocks: FxHashMap<BlockId, Block<'cfg>>,
-    next: FxHashMap<BlockId, Vec<(BlockId, JumpCond<'cfg>)>>,
+    next: BlockGraph<'cfg>,
     exprs: Vec<ExprData<'cfg>>,
     id_gen: Rc<RefCell<BlockIdGenerator>>,
     cur_id: BlockId,
@@ -157,7 +158,11 @@ impl<'cfg> Analyzer<'cfg, '_> {
 
         self.cur_id = self.id_gen.borrow_mut().generate();
 
-        self.next.entry(from).or_default().push((to, cond));
+        if let Some(edge) = self.next.edge_weight_mut(from, to) {
+            edge.push(cond);
+        } else {
+            self.next.add_edge(from, to, vec![cond]);
+        }
     }
 
     fn jump_cond(&mut self, test: ExprData<'cfg>, to: BlockId, if_true: bool) {

ecmascript/optimizer/src/control_flow_graph/traversal.rs

@@ -1,7 +1,7 @@
+use super::ControlFlowGraph;
 use crate::basic_block::Block;
 use crate::basic_block::JumpCond;
 use crate::block_id::BlockId;
-
 pub(crate) trait Visitor<'cfg> {
     fn visit_block(
         &mut self,
@@ -11,3 +11,11 @@ pub(crate) trait Visitor<'cfg> {
     ) {
     }
 }
+
+impl<'cfg> ControlFlowGraph<'cfg> {
+    pub(crate) fn traverse<V>(&mut self, v: &mut V)
+    where
+        V: Visitor<'cfg>,
+    {
+    }
+}

ecmascript/optimizer/src/lib.rs

@@ -1,6 +1,35 @@
+use crate::ast::clean_up;
+use crate::ast::prepare;
+use crate::control_flow_graph::ControlFlowGraph;
+use crate::dce::remove_dead_code;
+use swc_ecma_ast::*;
+
 mod ast;
-pub mod basic_block;
-pub mod block_id;
-pub mod control_flow_graph;
-pub mod dce;
+mod basic_block;
+mod block_id;
+mod control_flow_graph;
+mod dce;
 mod mutations;
+
+#[derive(Debug, Clone, Copy)]
+pub struct OptimizerConfig {
+    pub dce: bool,
+}
+
+pub fn optimize(m: &mut Module, config: OptimizerConfig) {
+    prepare(m);
+
+    let mutations = {
+        let mut cfg = ControlFlowGraph::anaylze(m);
+
+        if config.dce {
+            remove_dead_code(&mut cfg);
+        }
+
+        cfg.mutations
+    };
+
+    mutations.apply(m);
+
+    clean_up(m);
+}