chore: Make aggressive optimization default

Author: He-Pin

sjsonnet/src/sjsonnet/Settings.scala

@@ -13,14 +13,7 @@ final case class Settings(
     brokenAssertionLogic: Boolean = false,
     maxMaterializeDepth: Int = 1000,
     materializeRecursiveDepthLimit: Int = 128,
-    maxStack: Int = 500,
-    /**
-     * Enable aggressive static optimizations in the optimization phase, including: constant folding
-     * for arithmetic, comparison, bitwise, and shift operators; branch elimination for if-else with
-     * constant conditions; short-circuit elimination for And/Or with constant lhs. These reduce AST
-     * node count, benefiting long-running Jsonnet programs.
-     */
-    aggressiveStaticOptimization: Boolean = false
+    maxStack: Int = 500
 )
 
 object Settings {

sjsonnet/src/sjsonnet/StaticOptimizer.scala

@@ -9,8 +9,7 @@ import ScopedExprTransform.*
  * StaticOptimizer performs necessary transformations for the evaluator (assigning ValScope indices)
  * plus additional optimizations (post-order) and static checking (pre-order).
  *
- * When `aggressiveStaticOptimization` is enabled, the optimizer additionally performs during the
- * optimization phase:
+ * The optimizer performs:
  *   - Constant folding for arithmetic (+, -, *, /, %), comparison (<, >, <=, >=, ==, !=), bitwise
  *     (&, ^, |), shift (<<, >>), and unary (!, -, ~, +) operators.
  *   - Branch elimination for if-else with constant conditions.
@@ -32,8 +31,6 @@ class StaticOptimizer(
     extends ScopedExprTransform {
   def optimize(e: Expr): Expr = transform(e)
 
-  private val aggressiveOptimization = ev.settings.aggressiveStaticOptimization
-
   override def transform(_e: Expr): Expr = super.transform(check(_e)) match {
     case a: Apply => transformApply(a)
 
@@ -104,18 +101,8 @@ class StaticOptimizer(
       if (binds == null && asserts == null && allFieldsStaticAndUniquelyNamed)
         Val.staticObject(pos, fields, internedStaticFieldSets, internedStrings)
       else m
-
     // Aggressive optimizations: constant folding, branch elimination, short-circuit elimination.
     // These reduce AST node count at parse time, benefiting long-running Jsonnet programs.
-    case e => if (aggressiveOptimization) tryAggressiveOptimize(e) else e
-  }
-
-  /**
-   * Aggressive static optimizations that benefit long-running programs by reducing AST size.
-   * Includes: branch elimination, short-circuit elimination, constant folding for arithmetic,
-   * comparison, bitwise, and shift operators.
-   */
-  private def tryAggressiveOptimize(e: Expr): Expr = e match {
     // Constant folding: BinaryOp with two constant operands (most common case first)
     case e @ BinaryOp(pos, lhs: Val, op, rhs: Val) => tryFoldBinaryOp(pos, lhs, op, rhs, e)
 
@@ -139,8 +126,7 @@ class StaticOptimizer(
     case And(pos, _: Val.False, _)          => Val.False(pos)
     case Or(pos, _: Val.True, _)            => Val.True(pos)
     case Or(_, _: Val.False, rhs: Val.Bool) => rhs
-
-    case _ => e
+    case e                                  => e
   }
 
   private object ValidSuper {
@@ -400,25 +386,20 @@ class StaticOptimizer(
           }
         case BinaryOp.OP_& =>
           (lhs, rhs) match {
-            case (Val.Num(_, _), Val.Num(_, _)) =>
-              Val.Num(
-                pos,
-                (lhs.asInstanceOf[Val.Num].asSafeLong & rhs
-                  .asInstanceOf[Val.Num]
-                  .asSafeLong).toDouble
-              )
+            case (l: Val.Num, r: Val.Num) =>
+              Val.Num(pos, (l.asSafeLong & r.asSafeLong).toDouble)
             case _ => fallback
           }
         case BinaryOp.OP_^ =>
           (lhs, rhs) match {
-            case (Val.Num(_, _), Val.Num(_, _)) =>
-              Val.Num(pos, (lhs.asLong ^ rhs.asLong).toDouble)
+            case (l: Val.Num, r: Val.Num) =>
+              Val.Num(pos, (l.asSafeLong ^ r.asSafeLong).toDouble)
             case _ => fallback
           }
         case BinaryOp.OP_| =>
           (lhs, rhs) match {
-            case (Val.Num(_, _), Val.Num(_, _)) =>
-              Val.Num(pos, (lhs.asLong | rhs.asLong).toDouble)
+            case (l: Val.Num, r: Val.Num) =>
+              Val.Num(pos, (l.asSafeLong | r.asSafeLong).toDouble)
             case _ => fallback
           }
         case _ => fallback

sjsonnet/test/resources/test_suite/error.recursive_import.jsonnet.golden

@@ -1,2 +1,2 @@
 sjsonnet.Error: Max stack frames exceeded.
-    at [<root>].(error.recursive_import.jsonnet:17:1)
+    at [<root>].(error.recursive_import.jsonnet:17:15)