Reduce lifted out variants.

src/engine.rs

@@ -369,8 +369,15 @@ impl Engine {
     }
 
     /// Imitation of std::hints::black_box which requires nightly.
+    #[cfg(not(target_family = "wasm"))]
     #[inline(never)]
     pub(crate) fn black_box() -> usize {
         unsafe { core::ptr::read_volatile(&0_usize as *const usize) }
     }
+    /// Imitation of std::hints::black_box which requires nightly.
+    #[cfg(target_family = "wasm")]
+    #[inline(always)]
+    pub(crate) fn black_box() -> usize {
+        0
+    }
 }

src/eval/expr.rs

@@ -254,8 +254,6 @@ impl Engine {
         }
 
         // Then variable access.
-        // We shouldn't do this for too many variants because, soon or later, the added comparisons
-        // will cost more than the mis-predicted `match` branch.
         if let Expr::Variable(x, index, var_pos) = expr {
             return if index.is_none() && x.0.is_none() && x.3 == KEYWORD_THIS {
                 this_ptr
@@ -267,41 +265,27 @@ impl Engine {
             };
         }
 
-        // Stop merging branches here!
+        // Then integer constants.
-        Self::black_box();
-
-        // Constants
         if let Expr::IntegerConstant(x, ..) = expr {
             return Ok((*x).into());
         }
-        if let Expr::StringConstant(x, ..) = expr {
-            return Ok(x.clone().into());
-        }
-        if let Expr::BoolConstant(x, ..) = expr {
-            return Ok((*x).into());
-        }
-
-        // Stop merging branches here!
-        Self::black_box();
-
-        #[cfg(not(feature = "no_float"))]
-        if let Expr::FloatConstant(x, ..) = expr {
-            return Ok((*x).into());
-        }
-        if let Expr::CharConstant(x, ..) = expr {
-            return Ok((*x).into());
-        }
-        if let Expr::Unit(..) = expr {
-            return Ok(Dynamic::UNIT);
-        }
-        if let Expr::DynamicConstant(x, ..) = expr {
-            return Ok(x.as_ref().clone());
-        }
 
         // Stop merging branches here!
+        // We shouldn't lift out too many variants because, soon or later, the added comparisons
+        // will cost more than the mis-predicted `match` branch.
         Self::black_box();
 
         match expr {
+            // Constants
+            Expr::IntegerConstant(..) => unreachable!(),
+            Expr::StringConstant(x, ..) => Ok(x.clone().into()),
+            Expr::BoolConstant(x, ..) => Ok((*x).into()),
+            #[cfg(not(feature = "no_float"))]
+            Expr::FloatConstant(x, ..) => Ok((*x).into()),
+            Expr::CharConstant(x, ..) => Ok((*x).into()),
+            Expr::Unit(..) => Ok(Dynamic::UNIT),
+            Expr::DynamicConstant(x, ..) => Ok(x.as_ref().clone()),
+
             // `... ${...} ...`
             Expr::InterpolatedString(x, _) => {
                 let mut concat = SmartString::new_const();
@@ -445,8 +429,13 @@ impl Engine {
                     .and_then(|r| self.check_data_size(r, expr.start_position()))
             }
 
-            Expr::Stmt(x) if x.is_empty() => Ok(Dynamic::UNIT),
+            Expr::Stmt(x) => {
-            Expr::Stmt(x) => self.eval_stmt_block(global, caches, scope, this_ptr, x, true),
+                if x.is_empty() {
+                    Ok(Dynamic::UNIT)
+                } else {
+                    self.eval_stmt_block(global, caches, scope, this_ptr, x, true)
+                }
+            }
 
             #[cfg(not(feature = "no_index"))]
             Expr::Index(..) => {

src/eval/stmt.rs

@@ -277,7 +277,6 @@ impl Engine {
 
         // Coded this way for better branch prediction.
         // Popular branches are lifted out of the `match` statement into their own branches.
-        // Hopefully the compiler won't undo all this work!
 
         // Function calls should account for a relatively larger portion of statements.
         if let Stmt::FnCall(x, pos) = stmt {
@@ -285,8 +284,6 @@ impl Engine {
         }
 
         // Then assignments.
-        // We shouldn't do this for too many variants because, soon or later, the added comparisons
-        // will cost more than the mis-predicted `match` branch.
         if let Stmt::Assignment(x, ..) = stmt {
             let (op_info, BinaryExpr { lhs, rhs }) = &**x;
 
@@ -353,22 +350,12 @@ impl Engine {
             }
         }
 
-        // Stop merging branches here!
+        // Then variable definitions.
-        Self::black_box();
-
-        // Block scope
-        if let Stmt::Block(statements, ..) = stmt {
-            return if statements.is_empty() {
-                Ok(Dynamic::UNIT)
-            } else {
-                self.eval_stmt_block(global, caches, scope, this_ptr, statements, true)
-            };
-        }
-
         if let Stmt::Var(x, options, pos) = stmt {
             if !self.allow_shadowing() && scope.contains(&x.0) {
                 return Err(ERR::ErrorVariableExists(x.0.to_string(), *pos).into());
             }
+
             // Let/const statement
             let (var_name, expr, index) = &**x;
 
@@ -451,10 +438,30 @@ impl Engine {
         }
 
         // Stop merging branches here!
+        // We shouldn't lift out too many variants because, soon or later, the added comparisons
+        // will cost more than the mis-predicted `match` branch.
         Self::black_box();
 
+        match stmt {
+            // No-op
+            Stmt::Noop(..) => Ok(Dynamic::UNIT),
+
+            // Expression as statement
+            Stmt::Expr(expr) => self
+                .eval_expr(global, caches, scope, this_ptr, expr)
+                .map(Dynamic::flatten),
+
+            // Block scope
+            Stmt::Block(statements, ..) => {
+                if statements.is_empty() {
+                    Ok(Dynamic::UNIT)
+                } else {
+                    self.eval_stmt_block(global, caches, scope, this_ptr, statements, true)
+                }
+            }
+
             // If statement
-        if let Stmt::If(x, ..) = stmt {
+            Stmt::If(x, ..) => {
                 let FlowControl {
                     expr,
                     body: if_block,
@@ -466,7 +473,7 @@ impl Engine {
                     .as_bool()
                     .map_err(|typ| self.make_type_mismatch_err::<bool>(typ, expr.position()))?;
 
-            return match guard_val {
+                match guard_val {
                     true if !if_block.is_empty() => {
                         self.eval_stmt_block(global, caches, scope, this_ptr, if_block, true)
                     }
@@ -474,25 +481,9 @@ impl Engine {
                         self.eval_stmt_block(global, caches, scope, this_ptr, else_block, true)
                     }
                     _ => Ok(Dynamic::UNIT),
-            };
+                }
             }
 
-        // Expression as statement
-        if let Stmt::Expr(expr) = stmt {
-            return self
-                .eval_expr(global, caches, scope, this_ptr, expr)
-                .map(Dynamic::flatten);
-        }
-
-        // No-op
-        if let Stmt::Noop(..) = stmt {
-            return Ok(Dynamic::UNIT);
-        }
-
-        // Stop merging branches here!
-        Self::black_box();
-
-        match stmt {
             // Switch statement
             Stmt::Switch(x, ..) => {
                 let (