Make sure boxing effect detectable

With this change the two benchmarks shows the effect of boxing:

- lambdaBench:      445.352 ns/op
- lambdaNoboxBench: 60.220  ns/op

Previously, they have the same result because the boxing effect is shadowed
by the method call effect.

By doing more unboxing work in the method, we make sure the effect is visible
in the result.

Author: liufengyun

bench-run/src/main/scala/dotty/tools/benchmarks/specialization/Functions.scala

@@ -33,38 +33,50 @@ class Functions {
   }
 
 
-  var fn = (x: Int) => x + 1
+  var fn = (x: Int) =>  100000.times { x } + 5
   var arr = Array(fn, null)
   @Benchmark
-  def lambdaBench(): Int = 10000.times {
+  def lambdaBench(): Int = 1000.times {
     arr(1) = null
     arr(0)(2)
   }
 
+  class FunctionNoBox extends Function1[Int, Int] {
+    def apply(x: Int): Int = 10000.times { x } + 5
+  }
+  var fnNobox = new FunctionNoBox
+  var arrNobox: Array[FunctionNoBox] = Array(fnNobox, null)
+  @Benchmark
+  def lambdaNoboxBench(): Int = 1000.times {
+    arrNobox(1) = null
+    arrNobox(0)(2)
+  }
+
+
   class Func1[T](fn: T => Int) extends Function1[T, Int] {
     def apply(x: T): Int = fn(x)
   }
-  class Fn extends Func1(identity[Int])
+  class Fn extends Func1((x: Int) => 10000.times { x } + 5)
 
   var fn1: Function1[Int, Int] = new Fn
   var arr1 = Array(fn1, null)
 
   @Benchmark
-  def extendFun1Bench(): Int = 10000.times {
+  def extendFun1Bench(): Int = 1000.times {
     arr1(1) = null
     arr1(0)(12)
   }
 
 
   class Func2 extends Function2[Int, Int, Int] {
-    def apply(i: Int, j: Int) = i + j
+    def apply(i: Int, j: Int) = 10000.times { i } + j
   }
 
   var fn2: Function2[Int, Int, Int] = new Func2
   var arr2 = Array(fn2, null)
 
   @Benchmark
-  def extendFun2Bench(): Int = 10000.times {
+  def extendFun2Bench(): Int = 1000.times {
     arr2(1) = null
     arr2(0)(1300, 37)
   }