[ test, perf ] Add couple of kinda-performance tests

examples/pil-fun/tests/gens/scala3-big/expected

@@ -0,0 +1,299 @@
+-------------------
+
+extension (lsbhzmuum: Int)
+  def f(g: Boolean, zhdjsjn: Boolean, bzxbnt: Int, kcykprmz: Boolean, j: Int, pofpamn: Int): Unit = {
+    def bjzxbceo(vr: Boolean, aqh: Boolean, vgpeorkzyw: Boolean, tjwddp: Int, vaezbrut: Boolean) =
+      extension (viradza: Boolean)
+        def ochswyeoo(urqplbpag: Boolean, kxswdyvkau: Boolean, dxod: Boolean): Boolean = {
+          Console.println((7.+(tjwddp)).+(tjwddp + 7))
+          val eqibjfxxwk = 3
+          if (tjwddp.==(7)) && (0 < (7.+(7))) then {
+            val otmkdghq = (7 + tjwddp).+(tjwddp + (6.+(3)))
+
+          } else {
+            val ypll = (dnwfdiifst: Int, kqedtsy: Int) =>
+              false 
+
+          }
+          Console.println((tjwddp.+(0)).+(0 + tjwddp))
+          true || (3 == (tjwddp.+(3)))
+        } : Boolean
+      val hb = () => {
+        extension (seg: Int)
+          def naqy(lfn: Boolean): Unit = {
+            if vr.ochswyeoo(3.<=(pofpamn), vgpeorkzyw, vgpeorkzyw.&&(vr && vr)) then {
+
+            } else {
+
+            }
+            if vgpeorkzyw then {
+
+            }
+
+          } 
+        if true.ochswyeoo(aqh.||(true), vr || aqh, kcykprmz.ochswyeoo(true, aqh, vr)) then {
+          (j.+(j.+(j))).naqy((j + 7) == 1)
+
+        } else {
+          val tuihc = (p: Boolean) =>
+            (pofpamn.+(2)) + (6 + 4) 
+
+        }
+        5 naqy false
+
+      } : Unit
+      if vgpeorkzyw then {
+        hb()
+        hb()
+
+      } else {
+        var oqj: Boolean = true.ochswyeoo(0 == j, true || false, false)
+        if false.ochswyeoo(tjwddp.<=(pofpamn), pofpamn == j, vr.ochswyeoo(vgpeorkzyw, vr, false)) then {
+
+        } else {
+
+        }
+
+      }
+      val omu = (hufz: Int) => {
+        extension (y: Boolean) def zqh(fzjuxude: Boolean): Int = { 2 + 7 } 
+
+      } 
+      extension (k: Boolean)
+        def gwdekh(qjwjul: Boolean, gxeqlbtyx: Boolean, xdkbf: Int, lrxkafuei: Boolean) = { (tjwddp + tjwddp).+(tjwddp + (7.+(tjwddp))) } 
+
+    if kcykprmz then
+      val kbabzad = (7.+(2)).+(pofpamn + (bzxbnt.+(bzxbnt)))
+      bjzxbceo(false, false.&&(false), false.&&(!(kcykprmz)), 1.+(1 + kbabzad), !(1 == 2))
+      val nq = (cmyobf: Boolean, huqexo: Boolean, zqjoqhc: Int, npsdrjl: Boolean) => {
+        extension (cwmxl: Boolean) def rgoh(rxrn: Boolean, gwlvzwkq: Boolean, dswokhsap: Boolean, cxalh: Int, b: Boolean, qmrj: Int): Unit = {  } 
+
+      } : Unit
+      if (bzxbnt.==(lsbhzmuum)) || (g && (zhdjsjn && false)) then
+        {}
+
+    else
+      bjzxbceo(zhdjsjn, zhdjsjn, false.||(true), 5, g || (true && (!(g))))
+      if (lsbhzmuum + lsbhzmuum).==(2 + (lsbhzmuum.+(5))) then {
+
+      } else {
+        val slhuhvgxj = (eysb: Int, bzvphqjmab: Boolean, rnkab: Int, gwjkn: Boolean) => {
+          val fbp = (obe: Boolean, l: Boolean, ohvxpkk: Int) => {  } : Unit
+          false.||(kcykprmz.&&(bzvphqjmab))
+        } : Boolean
+        bjzxbceo(zhdjsjn, true, 0.==(6), lsbhzmuum.+(lsbhzmuum.+(lsbhzmuum)), slhuhvgxj(6, false, 4, pofpamn == lsbhzmuum))
+
+      }
+      val zm = g
+      val v = () => { lsbhzmuum.+(lsbhzmuum.+(2.+(bzxbnt))) } 
+
+    val isxqgqhpn = 3
+    if lsbhzmuum == (7.+(pofpamn)) then {
+      if (!(true)) || ((!(kcykprmz)) && g) then
+        {}
+      else
+        var ncdficbyg = (0 + lsbhzmuum).+(3.+(6.+(2)))
+
+
+    } else {
+      val kopmjkfxqc = (uhkjm: Boolean, zpucu: Boolean, oywl: Boolean, pm: Boolean, ecl: Int, bgwwsmfgc: Int) => {
+        extension (vfc: Int) def mg(rhpvtn: Int, gkzppygn: Boolean, fynouiswxi: Boolean): Int = { (ecl.+(vfc)) + (ecl.+(4 + 7)) } : Int
+
+      } : Unit
+      bjzxbceo(zhdjsjn, lsbhzmuum.==(3), 1 == 3, 4.+(4.+(3)), (bzxbnt + 6).==(6.+(4)))
+
+    }
+
+  } 
+
+@main
+def nnrdtjkx(): Unit = {
+  if (6 + 4) == 3 then {
+    if false then
+      3.f(true, !(false), 0 + 6, true, 1 + (4 + 0), 6.+(0.+(7)))
+      6.f(true, !(true), 2 + 1, 6.<=(4), 5 + (7.+(1)), 7.+(4 + 3))
+      var ltszwkd = (5.+(5)).+(4 + (1 + 1))
+      if (ltszwkd + ltszwkd).==(ltszwkd + 4) then {
+
+      }
+
+    else
+      def yopcgm(kberik: Int, sshmtadbj: Boolean, wzmrcfnc: Int, i: Int, gxnzfx: Boolean, txuelhidi: Int) =
+        def entrdwrxol(qrkjobhkoz: Int, nepwgyzn: Int, uy: Boolean) =
+          5.f(sshmtadbj, true, i, !(true), 6 + wzmrcfnc, 4.+(3))
+          extension (hide: Boolean)
+            def xbjtxt(zpljmsul: Int, t: Boolean, qdicfwb: Boolean, vxhyd: Boolean, ebqobvrg: Int): Unit =
+              {} 
+          (sshmtadbj && true) && (true || false) 
+        if sshmtadbj then {
+
+        } else {
+          def quwdhtki() =
+            entrdwrxol(wzmrcfnc.+(kberik), kberik + 1, entrdwrxol(kberik, kberik, sshmtadbj.||(true))) 
+
+        }
+        kberik.f(true, false, 4, false || false, i + (txuelhidi.+(7)), (1.+(kberik)).+(kberik.+(0)))
+
+      val wvw: Int = (0.+(0)).+(4)
+      var vhnp: Int = 7
+      vhnp = (3 + 2) + 5
+
+    val xfb = (fvzwxya: Boolean, mqemczi: Boolean, wkfxa: Boolean, wv: Boolean, cti: Boolean, nxcsam: Int) => {
+      var ohssei: Boolean = (nxcsam.+(3)).==(nxcsam.+(nxcsam.+(2)))
+      ohssei = mqemczi
+      5.f(true, !(ohssei), 0.+(nxcsam), nxcsam == nxcsam, 0 + (nxcsam.+(nxcsam)), 1)
+
+    } : Unit
+    val igu = (5 + 3) + (1.+(3.+(4)))
+
+  } else {
+    if (5.+(3)) == (6.+(6.+(5))) then
+      if (true || (!(true))).&&(6 <= 4) then {
+        if (4 <= 7).&&(7 == 6) then
+          6.f(true, false, 5 + 7, false && (!(true)), 2 + (2.+(3)), (5 + 2).+(4))
+          val rsebaxwtd: Int = (3 + 5).+(1 + 6)
+
+        else
+          val dfnclwya: Int = 0 + (7.+(6))
+
+        if true then
+          0.f(true, false, 5 + 2, 2.==(7), 2 + (4.+(7)), (1 + 1).+(7 + 2))
+
+        else
+          val bxcaf = !(4 <= (1.+(3)))
+
+
+      } else {
+        var rrdv = 3.+(6 + (1.+(1)))
+        if (!(!(false))).&&((!(true)).&&(false.&&(false))) then {
+          extension (whbsqvi: Boolean) def xcsjakiieb(qdxfpf: Boolean, ghix: Boolean): Unit = {  } : Unit
+
+        } else {
+          rrdv = (rrdv + 7) + (1 + rrdv)
+
+        }
+        rrdv.f(false, !(true), rrdv, false, rrdv, rrdv.+(rrdv))
+
+      }
+      extension (ebedfdsy: Boolean)
+        def ktqlcles(aytjcbxl: Boolean, ycvic: Boolean, kkdwd: Boolean, hbwucxlwb: Int, nopwim: Boolean, wy: Int) = {
+          def fep(wcmeyqttd: Boolean, hmnimcmdmb: Boolean, oqc: Int, qc: Boolean, gglip: Boolean, fhecmkilwq: Int) = {
+            if !((!(true)).&&(!(false))) then {
+
+            }
+            (wy + 4) + (wy + (7.+(5)))
+          } 
+          if (2.+(6)) < (1 + (wy.+(hbwucxlwb))) then {
+
+          }
+          hbwucxlwb.==(6)
+        } 
+      if true || true then
+        {}
+      else
+        0.f(false, false, 1.+(3), true.&&(true), 4 + (5 + 6), 4.+(5 + 5))
+
+
+    else
+      extension (ztqxsw: Boolean)
+        def dixlzn(vkdgl: Boolean): Int =
+          def hyh(yr: Int) = {
+            yr.f(ztqxsw, !(false), 4 + yr, true.||(!(ztqxsw)), yr, (1.+(yr)) + (yr.+(yr)))
+            def t(ycfvjun: Boolean, x: Int, gdcgpkzlp: Int, pj: Int, jqqmg: Boolean, iy: Boolean, ycpwl: Int) = { yr } 
+            (3 + yr) + (yr.+(1))
+          } 
+          7.f(ztqxsw, false, hyh(6), false && ztqxsw, hyh(3) + 6, (0.+(6)).+(hyh(hyh(5))))
+          var dnzjab: Boolean = (2.<(hyh(5))) || (ztqxsw || (ztqxsw.||(ztqxsw)))
+          (4.+(3)) + 0 
+      if (false.&&(false)) || (true || false) then {
+        if (3 == 2) || (true || (5 < 6)) then {
+
+        } else {
+          if (1 == 6) && (false || (4 == 0)) then {
+
+          } else {
+
+          }
+
+        }
+        0.f(true, true, 2.+(5), 7.==(6), 5.+(false.dixlzn(true)), false.dixlzn(true.||(true)))
+
+      } else {
+        val xikz = (6 < 0).dixlzn(2.==(true dixlzn true))
+        var alcsccds = xikz.+(xikz + (true dixlzn true))
+
+      }
+      2.f(true, false, false dixlzn true, 7.==(4), true.dixlzn(4 == 1), (true.||(true)) dixlzn (0.<(3)))
+      if (4.==(6)) || (3.<=(5)) then {
+
+      }
+
+    extension (c: Boolean)
+      def vimqhhecmj(pciwteqyeg: Boolean, i: Int): Unit = {
+        extension (fmur: Boolean)
+          def gm(catxxjb: Boolean) =
+            {} 
+
+      } : Unit
+    if (7 + 4).<=(6.+(1.+(6))) then
+      if 7.==(0 + (6 + 0)) then {
+
+      } else {
+        3.f(true, true, 1.+(3), 1 < 4, 3 + 5, (7.+(3)) + 2)
+
+      }
+      val xje = (vvucin: Boolean, ykx: Boolean) => { {} } : Unit
+
+    else
+      def cpebujzqsq(tx: Boolean, gmowwc: Boolean, liioogmgn: Boolean, gstsfcyy: Boolean, cidva: Boolean, dncqpxsmyk: Boolean): Int = {
+        7.f(true, true, 3 + 0, 3.==(6), 3 + 1, 4)
+        (6.+(5)) + (0 + (5 + 6))
+      } 
+      var qkufrhxr: Int = cpebujzqsq(true, false, true, 6 == 6, true || true, 2 == (5.+(6)))
+
+    if (0 < 7).&&(6.==(5)) then {
+      0.f(false, true, 1 + 0, 2 < 1, 7.+(2.+(7)), (4 + 6) + (6.+(2)))
+
+    }
+    if (3.<(1)).&&(true) then {
+
+    } else {
+
+    }
+
+  }
+  extension (vh: Boolean)
+    def aeiurowfu(jwwzhjw: Boolean, ibz: Boolean, yqncdnqvpn: Int) = {
+      if false then
+        var rtikn: Int = (yqncdnqvpn.+(3)).+(5.+(7))
+
+      else
+        if (true.&&(!(vh))).||(yqncdnqvpn <= (3.+(2))) then
+          var eayrlw = 2
+
+        else
+          if (yqncdnqvpn.==(0)) || (!(!(ibz))) then
+            0.f(vh, !(false), yqncdnqvpn.+(yqncdnqvpn), true || false, 2, 4 + yqncdnqvpn)
+
+          else
+            if ibz || (true.&&(yqncdnqvpn == 2)) then
+              {}
+            else
+              {}
+
+          7.f(vh, ibz, 0, false, 4.+(yqncdnqvpn.+(2)), 2)
+
+        6.f(true, !(jwwzhjw), 6.+(1), yqncdnqvpn == yqncdnqvpn, yqncdnqvpn + yqncdnqvpn, (1 + yqncdnqvpn).+(yqncdnqvpn))
+        val ej = (e: Int, csduuukao: Int, icultio: Boolean) => {  } : Unit
+
+      var zdxgniq: Int = (yqncdnqvpn.+(2)) + (yqncdnqvpn + yqncdnqvpn)
+      zdxgniq = yqncdnqvpn + (yqncdnqvpn.+(yqncdnqvpn + 4))
+      var op = (yqncdnqvpn.+(0)) + yqncdnqvpn
+
+    } 
+  2.f(true, false, 0.+(4), 7 == 2, 6.+(1.+(5)), 7.+(3.+(3)))
+  val krpizyyqcz = (m: Int, hae: Boolean, g: Boolean, qlbexdotf: Int) => { g } 
+  true.aeiurowfu(2.==(4), krpizyyqcz(2, true, true, 2), 7 + (1.+(5)))
+  val qqhmi = krpizyyqcz(5, false || false, false, 3.+(2))
+
+}

examples/pil-fun/tests/gens/scala3-big/run

@@ -0,0 +1,6 @@
+rm -rf build
+
+flock "$1" pack -q install-deps pil-fun && \
+pack run pil-fun scala3 --seed 0,3 --tests 1 --model-fuel 6
+
+rm -rf build