diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index 6d54d1a17059..298105445393 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -620,6 +620,69 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL { reducingTransformListApply(rest.elems.length) { super.transform(localTyper.typedPos(tree.pos)(consed)) } + + //methods on Double + //new Predef.doubleToDouble(x).isNaN() -> java.lang.Double.isNaN(x) + //new Predef.doubleToDouble(x).isInfinite() -> java.lang.Double.isInfinity(x) + //methods on Float + //new Predef.float2Float(x).isNaN() -> java.lang.Double.isNaN(x) + //new Predef.float2Float(x).isInfinite() -> java.lang.Double.isInfinity(x) + + //methods on Number + //new Predef.(x).byteValue() -> x.toByte() + //new Predef.(x).shortValue() -> x.toShort() + //new Predef.(x).intValue() -> x.toInt() + //new Predef.(x).longValue() -> x.toLong() + //new Predef.(x).floatValue() -> x.toFloat() + //new Predef.(x).doubleValue() -> x.toDouble() + // + // for each of the conversions + // double2Double + // float2Float + // byte2Byte + // short2Short + // char2Character + // int2Integer + // long2Long + // boolean2Boolean + // + case Apply(Select(Apply(boxing @ Select(qual, _), params), methodName), Nil) + if currentRun.runDefinitions.PreDef_primitives2Primitives.contains(boxing.symbol) && + params.size == 1 && + allPrimitiveMethodsToRewrite.contains(methodName) && + treeInfo.isExprSafeToInline(qual) => + val newTree = + if (doubleAndFloatRedirectMethods.contains(methodName)) { + val cls = + if (boxing.symbol == currentRun.runDefinitions.Predef_double2Double) + definitions.BoxedDoubleClass + else definitions.BoxedFloatClass + + val targetMethod = cls.companionModule.info.decl(doubleAndFloatRedirectMethods(methodName)) + gen.mkMethodCall(targetMethod, params) + } else { + gen.mkMethodCall(Select(params.head, javaNumberConversions(methodName)), Nil) + } + super.transform(localTyper.typedPos(tree.pos)(newTree)) + + //(x:Int).hashCode is transformed to scala.Int.box(x).hashCode() + //(x:Int).toString is transformed to scala.Int.box(x).toString() + // + //rewrite + // scala.Int.box(x).hashCode() -> java.lang.Integer.hashCode(x) + // scala.Int.box(x).toString() -> java.lang.Integer.toString(x) + // similarly for all primitive types + case Apply(Select(Apply(box @ Select(boxer, _), params), methodName), Nil) + if objectMethods.contains(methodName) && + params.size == 1 && + currentRun.runDefinitions.isBox(box.symbol) && + treeInfo.isExprSafeToInline(boxer) + => + val target = boxedClass(boxer.symbol.companion) + val targetMethod = target.companionModule.info.decl(methodName) + val newTree = gen.mkMethodCall(targetMethod, params) + super.transform(localTyper.typedPos(tree.pos)(newTree)) + // Seq() ~> Nil (note: List() ~> Nil is rewritten in the Typer) case Apply(appMeth @ Select(appQual, _), List(nil)) if nil.symbol == NilModule && currentRun.runDefinitions.isSeqApply(appMeth) => @@ -633,4 +696,23 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL { } // CleanUpTransformer + + private val objectMethods = Map[Name, TermName]( + nme.hashCode_ -> nme.hashCode_, + nme.toString_ -> nme.toString_ + ) + private val doubleAndFloatRedirectMethods = Map[Name, TermName]( + nme.isNaN -> nme.isNaN, + nme.isInfinite -> nme.isInfinite + ) + private val javaNumberConversions = Map[Name, TermName]( + nme.byteValue -> nme.toByte, + nme.shortValue -> nme.toShort, + nme.intValue -> nme.toInt, + nme.longValue -> nme.toLong, + nme.floatValue -> nme.toFloat, + nme.doubleValue -> nme.toDouble + ) + private val allPrimitiveMethodsToRewrite = doubleAndFloatRedirectMethods.keySet ++ javaNumberConversions.keySet + } diff --git a/src/library/scala/runtime/RichByte.scala b/src/library/scala/runtime/RichByte.scala index d1f2877ff1db..309f042ef22d 100644 --- a/src/library/scala/runtime/RichByte.scala +++ b/src/library/scala/runtime/RichByte.scala @@ -13,7 +13,6 @@ package scala package runtime - final class RichByte(val self: Byte) extends AnyVal with ScalaWholeNumberProxy[Byte] { protected def num = scala.math.Numeric.ByteIsIntegral protected def ord = scala.math.Ordering.Byte @@ -27,6 +26,9 @@ final class RichByte(val self: Byte) extends AnyVal with ScalaWholeNumberProxy[B override def isValidByte = true + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine signum and sign too but forwards binary compatibility doesn't allow us to. override def abs: Byte = math.abs(self).toByte override def max(that: Byte): Byte = math.max(self, that).toByte override def min(that: Byte): Byte = math.min(self, that).toByte diff --git a/src/library/scala/runtime/RichChar.scala b/src/library/scala/runtime/RichChar.scala index 3b841d77f60a..36235309ab54 100644 --- a/src/library/scala/runtime/RichChar.scala +++ b/src/library/scala/runtime/RichChar.scala @@ -13,9 +13,6 @@ package scala package runtime - -import java.lang.Character - final class RichChar(val self: Char) extends AnyVal with IntegralProxy[Char] { protected def num = scala.math.Numeric.CharIsIntegral protected def ord = scala.math.Ordering.Char @@ -29,6 +26,9 @@ final class RichChar(val self: Char) extends AnyVal with IntegralProxy[Char] { override def isValidChar = true + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine signum and sign too but forwards binary compatibility doesn't allow us to. override def abs: Char = self override def max(that: Char): Char = math.max(self.toInt, that.toInt).toChar override def min(that: Char): Char = math.min(self.toInt, that.toInt).toChar diff --git a/src/library/scala/runtime/RichDouble.scala b/src/library/scala/runtime/RichDouble.scala index 10c8937de129..72778674d293 100644 --- a/src/library/scala/runtime/RichDouble.scala +++ b/src/library/scala/runtime/RichDouble.scala @@ -42,10 +42,14 @@ final class RichDouble(val self: Double) extends AnyVal with FractionalProxy[Dou def isPosInfinity: Boolean = Double.PositiveInfinity == self def isNegInfinity: Boolean = Double.NegativeInfinity == self + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine sign too but forwards binary compatibility doesn't allow us to. override def abs: Double = math.abs(self) override def max(that: Double): Double = math.max(self, that) override def min(that: Double): Double = math.min(self, that) - @deprecated("signum does not handle -0.0 or Double.NaN; use `sign` method instead", since = "2.13.0") override def signum: Int = num.signum(self) + @deprecated("signum does not handle -0.0 or Double.NaN; use `sign` method instead", since = "2.13.0") + override def signum: Int = math.signum(self).toInt def round: Long = math.round(self) def ceil: Double = math.ceil(self) diff --git a/src/library/scala/runtime/RichFloat.scala b/src/library/scala/runtime/RichFloat.scala index 869730386536..962984a737b3 100644 --- a/src/library/scala/runtime/RichFloat.scala +++ b/src/library/scala/runtime/RichFloat.scala @@ -42,10 +42,14 @@ final class RichFloat(val self: Float) extends AnyVal with FractionalProxy[Float def isPosInfinity: Boolean = Float.PositiveInfinity == self def isNegInfinity: Boolean = Float.NegativeInfinity == self + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine sign too but forwards binary compatibility doesn't allow us to. override def abs: Float = math.abs(self) override def max(that: Float): Float = math.max(self, that) override def min(that: Float): Float = math.min(self, that) - @deprecated("signum does not handle -0.0f or Float.NaN; use `sign` method instead", since = "2.13.0") override def signum: Int = num.signum(self) + @deprecated("signum does not handle -0.0f or Float.NaN; use `sign` method instead", since = "2.13.0") + override def signum: Int = math.signum(self).toInt def round: Int = math.round(self) def ceil: Float = math.ceil(self.toDouble).toFloat diff --git a/src/library/scala/runtime/RichInt.scala b/src/library/scala/runtime/RichInt.scala index e3e38ec9615b..5538ba700ff1 100644 --- a/src/library/scala/runtime/RichInt.scala +++ b/src/library/scala/runtime/RichInt.scala @@ -36,6 +36,9 @@ final class RichInt(val self: Int) extends AnyVal with ScalaNumberProxy[Int] wit override def isValidInt = true def isValidLong = true + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine signum and sign too but forwards binary compatibility doesn't allow us to. override def abs: Int = math.abs(self) override def max(that: Int): Int = math.max(self, that) override def min(that: Int): Int = math.min(self, that) diff --git a/src/library/scala/runtime/RichLong.scala b/src/library/scala/runtime/RichLong.scala index 669386f3761b..e1802cd3c6aa 100644 --- a/src/library/scala/runtime/RichLong.scala +++ b/src/library/scala/runtime/RichLong.scala @@ -32,6 +32,9 @@ final class RichLong(val self: Long) extends AnyVal with IntegralProxy[Long] { // override def isValidFloat = self.toFloat.toLong == self && self != Long.MaxValue // override def isValidDouble = self.toDouble.toLong == self && self != Long.MaxValue + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine signum and sign too but forwards binary compatibility doesn't allow us to. override def abs: Long = math.abs(self) override def max(that: Long): Long = math.max(self, that) override def min(that: Long): Long = math.min(self, that) diff --git a/src/library/scala/runtime/RichShort.scala b/src/library/scala/runtime/RichShort.scala index ca61784241b7..b8ee71c19d9c 100644 --- a/src/library/scala/runtime/RichShort.scala +++ b/src/library/scala/runtime/RichShort.scala @@ -13,7 +13,6 @@ package scala package runtime - final class RichShort(val self: Short) extends AnyVal with ScalaWholeNumberProxy[Short] { protected def num = scala.math.Numeric.ShortIsIntegral protected def ord = scala.math.Ordering.Short @@ -27,6 +26,9 @@ final class RichShort(val self: Short) extends AnyVal with ScalaWholeNumberProxy override def isValidShort = true + // These method are all overridden and redefined to call out to scala.math to avoid 3 allocations: + // the primitive boxing, the value class boxing and instantiation of the Numeric num. + // We'd like to redefine signum and sign too but forwards binary compatibility doesn't allow us to. override def abs: Short = math.abs(self.toInt).toShort override def max(that: Short): Short = math.max(self.toInt, that.toInt).toShort override def min(that: Short): Short = math.min(self.toInt, that.toInt).toShort diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index c51dda31fbb4..94f0b464e67f 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -1758,6 +1758,20 @@ trait Definitions extends api.StandardDefinitions { lazy val SubType_refl = getMemberMethod(SubTypeModule, nme.refl) lazy val Predef_classOf = getMemberMethod(PredefModule, nme.classOf) + + lazy val Predef_double2Double = getMemberMethod(PredefModule, nme.double2Double) + lazy val Predef_float2Float = getMemberMethod(PredefModule, nme.float2Float) + lazy val Predef_byte2Byte = getMemberMethod(PredefModule, nme.byte2Byte) + lazy val Predef_short2Short = getMemberMethod(PredefModule, nme.short2Short) + lazy val Predef_char2Character = getMemberMethod(PredefModule, nme.char2Character) + lazy val Predef_int2Integer = getMemberMethod(PredefModule, nme.int2Integer) + lazy val Predef_long2Long = getMemberMethod(PredefModule, nme.long2Long) + lazy val Predef_boolean2Boolean = getMemberMethod(PredefModule, nme.boolean2Boolean) + + lazy val PreDef_primitives2Primitives = + Set[Symbol](Predef_double2Double, Predef_float2Float, Predef_byte2Byte, Predef_short2Short, + Predef_char2Character, Predef_int2Integer, Predef_long2Long, Predef_boolean2Boolean) + lazy val Predef_implicitly = getMemberMethod(PredefModule, nme.implicitly) lazy val Predef_??? = DefinitionsClass.this.Predef_??? lazy val Predef_any2stringaddMethod = getMemberMethod(PredefModule, nme.any2stringadd).suchThat(_.isMethod) diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala index 39757b254424..44b945dbfa2c 100644 --- a/src/reflect/scala/reflect/internal/StdNames.scala +++ b/src/reflect/scala/reflect/internal/StdNames.scala @@ -649,6 +649,15 @@ trait StdNames { val copyArrayToImmutableIndexedSeq: NameType = nameType("copyArrayToImmutableIndexedSeq") + val double2Double: NameType = nameType("double2Double") + val float2Float: NameType = nameType("float2Float") + val byte2Byte: NameType = nameType("byte2Byte") + val short2Short: NameType = nameType("short2Short") + val char2Character: NameType = nameType("char2Character") + val int2Integer: NameType = nameType("int2Integer") + val long2Long: NameType = nameType("long2Long") + val boolean2Boolean: NameType = nameType("boolean2Boolean") + // Compiler utilized names val AnnotatedType: NameType = nameType("AnnotatedType") @@ -720,6 +729,7 @@ trait StdNames { val async : NameType = nameType("async") val await : NameType = nameType("await") val box: NameType = nameType("box") + val byteValue: NameType = nameType("byteValue") val bytes: NameType = nameType("bytes") val c: NameType = nameType("c") val canEqual_ : NameType = nameType("canEqual") @@ -734,6 +744,7 @@ trait StdNames { val delayedInitArg: NameType = nameType("delayedInit$body") val dollarScope: NameType = nameType("$scope") val doubleHash: NameType = nameType("doubleHash") + val doubleValue: NameType = nameType("doubleValue") val drop: NameType = nameType("drop") val elem: NameType = nameType("elem") val noSelfType: NameType = nameType("noSelfType") @@ -754,6 +765,7 @@ trait StdNames { val find_ : NameType = nameType("find") val flatMap: NameType = nameType("flatMap") val floatHash: NameType = nameType("floatHash") + val floatValue: NameType = nameType("floatValue") val foreach: NameType = nameType("foreach") val freshTermName: NameType = nameType("freshTermName") val freshTypeName: NameType = nameType("freshTypeName") @@ -768,12 +780,15 @@ trait StdNames { val initialized : NameType = nameType("initialized") val internal: NameType = nameType("internal") val inlinedEquals: NameType = nameType("inlinedEquals") + val intValue: NameType = nameType("intValue") val ioobe : NameType = nameType("ioobe") val isArray: NameType = nameType("isArray") val isDefinedAt: NameType = nameType("isDefinedAt") val isEmpty: NameType = nameType("isEmpty") + val isInfinite: NameType = nameType("isInfinite") val isInstanceOf_ : NameType = nameType("isInstanceOf") val isInstanceOf_Ob : NameType = nameType(s"$$isInstanceOf") // looks like missing interpolator due to Any member in scope + val isNaN: NameType = nameType("isNaN") val java: NameType = nameType("java") val key: NameType = nameType("key") val lang: NameType = nameType("lang") @@ -781,6 +796,7 @@ trait StdNames { val lengthCompare: NameType = nameType("lengthCompare") val locally: NameType = nameType("locally") val longHash: NameType = nameType("longHash") + val longValue: NameType = nameType("longValue") val macroContext : NameType = nameType("c") val main: NameType = nameType("main") val manifestToTypeTag: NameType = nameType("manifestToTypeTag") @@ -835,6 +851,7 @@ trait StdNames { val setInfo: NameType = nameType("setInfo") val setSymbol: NameType = nameType("setSymbol") val setType: NameType = nameType("setType") + val shortValue: NameType = nameType("shortValue") val splice: NameType = nameType("splice") val staticClass : NameType = nameType("staticClass") val staticModule : NameType = nameType("staticModule") diff --git a/src/testkit/scala/tools/testkit/AllocationTest.scala b/src/testkit/scala/tools/testkit/AllocationTest.scala index b5c502d5dfa0..c0d361ac6eee 100644 --- a/src/testkit/scala/tools/testkit/AllocationTest.scala +++ b/src/testkit/scala/tools/testkit/AllocationTest.scala @@ -26,9 +26,9 @@ object AllocationTest { allocationCounter.setThreadAllocatedMemoryEnabled(true) private object coster extends AllocationTest { - def byte = 1.toByte + def byte = 99.toByte - def short = 1.toShort + def short = 9999.toShort def int = 100000000 @@ -38,9 +38,9 @@ object AllocationTest { def char = 's' - def float = 1F + def float = 123456F - def double = 1D + def double = 123456D @nowarn("cat=lint-nullary-unit") def unit = () diff --git a/test/files/run/t12062.check b/test/files/run/t12062.check new file mode 100644 index 000000000000..5488c353b6a6 --- /dev/null +++ b/test/files/run/t12062.check @@ -0,0 +1,374 @@ +warning: 1 deprecation (since 2.13.0); re-run with -deprecation for details +warning: 6 deprecations (since 2.13.0); re-run with -deprecation for details + +class TestByte +source-newSource1.scala,line-29 TestByte.super.() +source-newSource1.scala,line-3 1.toByte() +source-newSource1.scala,line-6 java.lang.Byte.toString(TestByte.this.value()) +source-newSource1.scala,line-6 TestByte.this.value() +source-newSource1.scala,line-7 java.lang.Byte.hashCode(TestByte.this.value()) +source-newSource1.scala,line-7 TestByte.this.value() +source-newSource1.scala,line-8 TestByte.this.value().$asInstanceOf[Int]() +source-newSource1.scala,line-8 TestByte.this.value() +source-newSource1.scala,line-10 TestByte.this.value().toFloat() +source-newSource1.scala,line-10 TestByte.this.value() +source-newSource1.scala,line-11 TestByte.this.value().toDouble() +source-newSource1.scala,line-11 TestByte.this.value() +source-newSource1.scala,line-12 TestByte.this.value().toLong() +source-newSource1.scala,line-12 TestByte.this.value() +source-newSource1.scala,line-13 TestByte.this.value().toInt() +source-newSource1.scala,line-13 TestByte.this.value() +source-newSource1.scala,line-14 TestByte.this.value().toShort() +source-newSource1.scala,line-14 TestByte.this.value() +source-newSource1.scala,line-15 TestByte.this.value().toByte() +source-newSource1.scala,line-15 TestByte.this.value() +source-newSource1.scala,line-17 scala.runtime.RichByte.max$extension(scala.Predef.byteWrapper(TestByte.this.value()), TestByte.this.value()) +source-newSource1.scala,line-17 scala.Predef.byteWrapper(TestByte.this.value()) +source-newSource1.scala,line-17 TestByte.this.value() +source-newSource1.scala,line-17 TestByte.this.value() +source-newSource1.scala,line-18 scala.runtime.RichByte.min$extension(scala.Predef.byteWrapper(TestByte.this.value()), TestByte.this.value()) +source-newSource1.scala,line-18 scala.Predef.byteWrapper(TestByte.this.value()) +source-newSource1.scala,line-18 TestByte.this.value() +source-newSource1.scala,line-18 TestByte.this.value() +source-newSource1.scala,line-19 scala.runtime.RichByte.abs$extension(scala.Predef.byteWrapper(TestByte.this.value())) +source-newSource1.scala,line-19 scala.Predef.byteWrapper(TestByte.this.value()) +source-newSource1.scala,line-19 TestByte.this.value() +source-newSource1.scala,line-20 new runtime.RichByte(scala.Predef.byteWrapper(TestByte.this.value())).signum() +source-newSource1.scala,line-20 new runtime.RichByte(scala.Predef.byteWrapper(TestByte.this.value())) +source-newSource1.scala,line-20 scala.Predef.byteWrapper(TestByte.this.value()) +source-newSource1.scala,line-20 TestByte.this.value() +source-newSource1.scala,line-22 TestByte.this.value().toByte() +source-newSource1.scala,line-22 TestByte.this.value() +source-newSource1.scala,line-23 TestByte.this.value().toShort() +source-newSource1.scala,line-23 TestByte.this.value() +source-newSource1.scala,line-24 TestByte.this.value().toInt() +source-newSource1.scala,line-24 TestByte.this.value() +source-newSource1.scala,line-25 TestByte.this.value().toLong() +source-newSource1.scala,line-25 TestByte.this.value() +source-newSource1.scala,line-26 TestByte.this.value().toFloat() +source-newSource1.scala,line-26 TestByte.this.value() +source-newSource1.scala,line-27 TestByte.this.value().toDouble() +source-newSource1.scala,line-27 TestByte.this.value() + + +class TestShort +source-newSource2.scala,line-29 TestShort.super.() +source-newSource2.scala,line-3 1.toShort() +source-newSource2.scala,line-6 java.lang.Short.toString(TestShort.this.value()) +source-newSource2.scala,line-6 TestShort.this.value() +source-newSource2.scala,line-7 java.lang.Short.hashCode(TestShort.this.value()) +source-newSource2.scala,line-7 TestShort.this.value() +source-newSource2.scala,line-8 TestShort.this.value().$asInstanceOf[Int]() +source-newSource2.scala,line-8 TestShort.this.value() +source-newSource2.scala,line-10 TestShort.this.value().toFloat() +source-newSource2.scala,line-10 TestShort.this.value() +source-newSource2.scala,line-11 TestShort.this.value().toDouble() +source-newSource2.scala,line-11 TestShort.this.value() +source-newSource2.scala,line-12 TestShort.this.value().toLong() +source-newSource2.scala,line-12 TestShort.this.value() +source-newSource2.scala,line-13 TestShort.this.value().toInt() +source-newSource2.scala,line-13 TestShort.this.value() +source-newSource2.scala,line-14 TestShort.this.value().toShort() +source-newSource2.scala,line-14 TestShort.this.value() +source-newSource2.scala,line-15 TestShort.this.value().toByte() +source-newSource2.scala,line-15 TestShort.this.value() +source-newSource2.scala,line-17 scala.runtime.RichShort.max$extension(scala.Predef.shortWrapper(TestShort.this.value()), TestShort.this.value()) +source-newSource2.scala,line-17 scala.Predef.shortWrapper(TestShort.this.value()) +source-newSource2.scala,line-17 TestShort.this.value() +source-newSource2.scala,line-17 TestShort.this.value() +source-newSource2.scala,line-18 scala.runtime.RichShort.min$extension(scala.Predef.shortWrapper(TestShort.this.value()), TestShort.this.value()) +source-newSource2.scala,line-18 scala.Predef.shortWrapper(TestShort.this.value()) +source-newSource2.scala,line-18 TestShort.this.value() +source-newSource2.scala,line-18 TestShort.this.value() +source-newSource2.scala,line-19 scala.runtime.RichShort.abs$extension(scala.Predef.shortWrapper(TestShort.this.value())) +source-newSource2.scala,line-19 scala.Predef.shortWrapper(TestShort.this.value()) +source-newSource2.scala,line-19 TestShort.this.value() +source-newSource2.scala,line-20 new runtime.RichShort(scala.Predef.shortWrapper(TestShort.this.value())).signum() +source-newSource2.scala,line-20 new runtime.RichShort(scala.Predef.shortWrapper(TestShort.this.value())) +source-newSource2.scala,line-20 scala.Predef.shortWrapper(TestShort.this.value()) +source-newSource2.scala,line-20 TestShort.this.value() +source-newSource2.scala,line-22 TestShort.this.value().toByte() +source-newSource2.scala,line-22 TestShort.this.value() +source-newSource2.scala,line-23 TestShort.this.value().toShort() +source-newSource2.scala,line-23 TestShort.this.value() +source-newSource2.scala,line-24 TestShort.this.value().toInt() +source-newSource2.scala,line-24 TestShort.this.value() +source-newSource2.scala,line-25 TestShort.this.value().toLong() +source-newSource2.scala,line-25 TestShort.this.value() +source-newSource2.scala,line-26 TestShort.this.value().toFloat() +source-newSource2.scala,line-26 TestShort.this.value() +source-newSource2.scala,line-27 TestShort.this.value().toDouble() +source-newSource2.scala,line-27 TestShort.this.value() + + +class TestInt +source-newSource3.scala,line-29 TestInt.super.() +source-newSource3.scala,line-3 1.toInt() +source-newSource3.scala,line-6 java.lang.Integer.toString(TestInt.this.value()) +source-newSource3.scala,line-6 TestInt.this.value() +source-newSource3.scala,line-7 java.lang.Integer.hashCode(TestInt.this.value()) +source-newSource3.scala,line-7 TestInt.this.value() +source-newSource3.scala,line-8 TestInt.this.value() +source-newSource3.scala,line-10 TestInt.this.value().toFloat() +source-newSource3.scala,line-10 TestInt.this.value() +source-newSource3.scala,line-11 TestInt.this.value().toDouble() +source-newSource3.scala,line-11 TestInt.this.value() +source-newSource3.scala,line-12 TestInt.this.value().toLong() +source-newSource3.scala,line-12 TestInt.this.value() +source-newSource3.scala,line-13 TestInt.this.value().toInt() +source-newSource3.scala,line-13 TestInt.this.value() +source-newSource3.scala,line-14 TestInt.this.value().toShort() +source-newSource3.scala,line-14 TestInt.this.value() +source-newSource3.scala,line-15 TestInt.this.value().toByte() +source-newSource3.scala,line-15 TestInt.this.value() +source-newSource3.scala,line-17 scala.runtime.RichInt.max$extension(scala.Predef.intWrapper(TestInt.this.value()), TestInt.this.value()) +source-newSource3.scala,line-17 scala.Predef.intWrapper(TestInt.this.value()) +source-newSource3.scala,line-17 TestInt.this.value() +source-newSource3.scala,line-17 TestInt.this.value() +source-newSource3.scala,line-18 scala.runtime.RichInt.min$extension(scala.Predef.intWrapper(TestInt.this.value()), TestInt.this.value()) +source-newSource3.scala,line-18 scala.Predef.intWrapper(TestInt.this.value()) +source-newSource3.scala,line-18 TestInt.this.value() +source-newSource3.scala,line-18 TestInt.this.value() +source-newSource3.scala,line-19 scala.runtime.RichInt.abs$extension(scala.Predef.intWrapper(TestInt.this.value())) +source-newSource3.scala,line-19 scala.Predef.intWrapper(TestInt.this.value()) +source-newSource3.scala,line-19 TestInt.this.value() +source-newSource3.scala,line-20 new runtime.RichInt(scala.Predef.intWrapper(TestInt.this.value())).signum() +source-newSource3.scala,line-20 new runtime.RichInt(scala.Predef.intWrapper(TestInt.this.value())) +source-newSource3.scala,line-20 scala.Predef.intWrapper(TestInt.this.value()) +source-newSource3.scala,line-20 TestInt.this.value() +source-newSource3.scala,line-22 TestInt.this.value().toByte() +source-newSource3.scala,line-22 TestInt.this.value() +source-newSource3.scala,line-23 TestInt.this.value().toShort() +source-newSource3.scala,line-23 TestInt.this.value() +source-newSource3.scala,line-24 TestInt.this.value().toInt() +source-newSource3.scala,line-24 TestInt.this.value() +source-newSource3.scala,line-25 TestInt.this.value().toLong() +source-newSource3.scala,line-25 TestInt.this.value() +source-newSource3.scala,line-26 TestInt.this.value().toFloat() +source-newSource3.scala,line-26 TestInt.this.value() +source-newSource3.scala,line-27 TestInt.this.value().toDouble() +source-newSource3.scala,line-27 TestInt.this.value() + + +class TestLong +source-newSource4.scala,line-29 TestLong.super.() +source-newSource4.scala,line-3 1.toLong() +source-newSource4.scala,line-6 java.lang.Long.toString(TestLong.this.value()) +source-newSource4.scala,line-6 TestLong.this.value() +source-newSource4.scala,line-7 java.lang.Long.hashCode(TestLong.this.value()) +source-newSource4.scala,line-7 TestLong.this.value() +source-newSource4.scala,line-8 scala.runtime.Statics.longHash(TestLong.this.value()) +source-newSource4.scala,line-8 TestLong.this.value() +source-newSource4.scala,line-10 TestLong.this.value().toFloat() +source-newSource4.scala,line-10 TestLong.this.value() +source-newSource4.scala,line-11 TestLong.this.value().toDouble() +source-newSource4.scala,line-11 TestLong.this.value() +source-newSource4.scala,line-12 TestLong.this.value().toLong() +source-newSource4.scala,line-12 TestLong.this.value() +source-newSource4.scala,line-13 TestLong.this.value().toInt() +source-newSource4.scala,line-13 TestLong.this.value() +source-newSource4.scala,line-14 TestLong.this.value().toShort() +source-newSource4.scala,line-14 TestLong.this.value() +source-newSource4.scala,line-15 TestLong.this.value().toByte() +source-newSource4.scala,line-15 TestLong.this.value() +source-newSource4.scala,line-17 scala.runtime.RichLong.max$extension(scala.Predef.longWrapper(TestLong.this.value()), TestLong.this.value()) +source-newSource4.scala,line-17 scala.Predef.longWrapper(TestLong.this.value()) +source-newSource4.scala,line-17 TestLong.this.value() +source-newSource4.scala,line-17 TestLong.this.value() +source-newSource4.scala,line-18 scala.runtime.RichLong.min$extension(scala.Predef.longWrapper(TestLong.this.value()), TestLong.this.value()) +source-newSource4.scala,line-18 scala.Predef.longWrapper(TestLong.this.value()) +source-newSource4.scala,line-18 TestLong.this.value() +source-newSource4.scala,line-18 TestLong.this.value() +source-newSource4.scala,line-19 scala.runtime.RichLong.abs$extension(scala.Predef.longWrapper(TestLong.this.value())) +source-newSource4.scala,line-19 scala.Predef.longWrapper(TestLong.this.value()) +source-newSource4.scala,line-19 TestLong.this.value() +source-newSource4.scala,line-20 new runtime.RichLong(scala.Predef.longWrapper(TestLong.this.value())).signum() +source-newSource4.scala,line-20 new runtime.RichLong(scala.Predef.longWrapper(TestLong.this.value())) +source-newSource4.scala,line-20 scala.Predef.longWrapper(TestLong.this.value()) +source-newSource4.scala,line-20 TestLong.this.value() +source-newSource4.scala,line-22 TestLong.this.value().toByte() +source-newSource4.scala,line-22 TestLong.this.value() +source-newSource4.scala,line-23 TestLong.this.value().toShort() +source-newSource4.scala,line-23 TestLong.this.value() +source-newSource4.scala,line-24 TestLong.this.value().toInt() +source-newSource4.scala,line-24 TestLong.this.value() +source-newSource4.scala,line-25 TestLong.this.value().toLong() +source-newSource4.scala,line-25 TestLong.this.value() +source-newSource4.scala,line-26 TestLong.this.value().toFloat() +source-newSource4.scala,line-26 TestLong.this.value() +source-newSource4.scala,line-27 TestLong.this.value().toDouble() +source-newSource4.scala,line-27 TestLong.this.value() + + +class TestBoolean +source-newSource5.scala,line-9 TestBoolean.super.() +source-newSource5.scala,line-6 java.lang.Boolean.toString(TestBoolean.this.value()) +source-newSource5.scala,line-6 TestBoolean.this.value() +source-newSource5.scala,line-7 java.lang.Boolean.hashCode(TestBoolean.this.value()) +source-newSource5.scala,line-7 TestBoolean.this.value() +source-newSource5.scala,line-8 TestBoolean.this.value() + + +class TestChar +source-newSource6.scala,line-9 TestChar.super.() +source-newSource6.scala,line-6 java.lang.Character.toString(TestChar.this.value()) +source-newSource6.scala,line-6 TestChar.this.value() +source-newSource6.scala,line-7 java.lang.Character.hashCode(TestChar.this.value()) +source-newSource6.scala,line-7 TestChar.this.value() +source-newSource6.scala,line-8 TestChar.this.value().$asInstanceOf[Int]() +source-newSource6.scala,line-8 TestChar.this.value() + + +class TestFloat +source-newSource7.scala,line-40 TestFloat.super.() +source-newSource7.scala,line-3 1.toFloat() +source-newSource7.scala,line-6 java.lang.Float.toString(TestFloat.this.value()) +source-newSource7.scala,line-6 TestFloat.this.value() +source-newSource7.scala,line-7 java.lang.Float.hashCode(TestFloat.this.value()) +source-newSource7.scala,line-7 TestFloat.this.value() +source-newSource7.scala,line-8 scala.runtime.Statics.floatHash(TestFloat.this.value()) +source-newSource7.scala,line-8 TestFloat.this.value() +source-newSource7.scala,line-10 java.lang.Float.isNaN(TestFloat.this.value()) +source-newSource7.scala,line-10 TestFloat.this.value() +source-newSource7.scala,line-11 scala.runtime.RichFloat.isInfinity$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-11 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-11 TestFloat.this.value() +source-newSource7.scala,line-12 java.lang.Float.isInfinite(TestFloat.this.value()) +source-newSource7.scala,line-12 TestFloat.this.value() +source-newSource7.scala,line-13 scala.runtime.RichFloat.isNegInfinity$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-13 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-13 TestFloat.this.value() +source-newSource7.scala,line-14 scala.runtime.RichFloat.isPosInfinity$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-14 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-14 TestFloat.this.value() +source-newSource7.scala,line-16 TestFloat.this.value().toFloat() +source-newSource7.scala,line-16 TestFloat.this.value() +source-newSource7.scala,line-17 TestFloat.this.value().toDouble() +source-newSource7.scala,line-17 TestFloat.this.value() +source-newSource7.scala,line-18 TestFloat.this.value().toLong() +source-newSource7.scala,line-18 TestFloat.this.value() +source-newSource7.scala,line-19 TestFloat.this.value().toInt() +source-newSource7.scala,line-19 TestFloat.this.value() +source-newSource7.scala,line-20 TestFloat.this.value().toShort() +source-newSource7.scala,line-20 TestFloat.this.value() +source-newSource7.scala,line-21 TestFloat.this.value().toByte() +source-newSource7.scala,line-21 TestFloat.this.value() +source-newSource7.scala,line-23 scala.runtime.RichFloat.max$extension(scala.Predef.floatWrapper(TestFloat.this.value()), TestFloat.this.value()) +source-newSource7.scala,line-23 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-23 TestFloat.this.value() +source-newSource7.scala,line-23 TestFloat.this.value() +source-newSource7.scala,line-24 scala.runtime.RichFloat.min$extension(scala.Predef.floatWrapper(TestFloat.this.value()), TestFloat.this.value()) +source-newSource7.scala,line-24 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-24 TestFloat.this.value() +source-newSource7.scala,line-24 TestFloat.this.value() +source-newSource7.scala,line-25 scala.runtime.RichFloat.abs$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-25 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-25 TestFloat.this.value() +source-newSource7.scala,line-26 scala.runtime.RichFloat.signum$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-26 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-26 TestFloat.this.value() +source-newSource7.scala,line-27 scala.runtime.RichFloat.round$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-27 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-27 TestFloat.this.value() +source-newSource7.scala,line-28 scala.runtime.RichFloat.ceil$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-28 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-28 TestFloat.this.value() +source-newSource7.scala,line-29 scala.runtime.RichFloat.floor$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-29 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-29 TestFloat.this.value() +source-newSource7.scala,line-30 scala.runtime.RichFloat.toRadians$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-30 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-30 TestFloat.this.value() +source-newSource7.scala,line-31 scala.runtime.RichFloat.toDegrees$extension(scala.Predef.floatWrapper(TestFloat.this.value())) +source-newSource7.scala,line-31 scala.Predef.floatWrapper(TestFloat.this.value()) +source-newSource7.scala,line-31 TestFloat.this.value() +source-newSource7.scala,line-33 TestFloat.this.value().toByte() +source-newSource7.scala,line-33 TestFloat.this.value() +source-newSource7.scala,line-34 TestFloat.this.value().toShort() +source-newSource7.scala,line-34 TestFloat.this.value() +source-newSource7.scala,line-35 TestFloat.this.value().toInt() +source-newSource7.scala,line-35 TestFloat.this.value() +source-newSource7.scala,line-36 TestFloat.this.value().toLong() +source-newSource7.scala,line-36 TestFloat.this.value() +source-newSource7.scala,line-37 TestFloat.this.value().toFloat() +source-newSource7.scala,line-37 TestFloat.this.value() +source-newSource7.scala,line-38 TestFloat.this.value().toDouble() +source-newSource7.scala,line-38 TestFloat.this.value() + + +class TestDouble +source-newSource8.scala,line-40 TestDouble.super.() +source-newSource8.scala,line-3 1.toDouble() +source-newSource8.scala,line-6 java.lang.Double.toString(TestDouble.this.value()) +source-newSource8.scala,line-6 TestDouble.this.value() +source-newSource8.scala,line-7 java.lang.Double.hashCode(TestDouble.this.value()) +source-newSource8.scala,line-7 TestDouble.this.value() +source-newSource8.scala,line-8 scala.runtime.Statics.doubleHash(TestDouble.this.value()) +source-newSource8.scala,line-8 TestDouble.this.value() +source-newSource8.scala,line-10 java.lang.Double.isNaN(TestDouble.this.value()) +source-newSource8.scala,line-10 TestDouble.this.value() +source-newSource8.scala,line-11 scala.runtime.RichDouble.isInfinity$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-11 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-11 TestDouble.this.value() +source-newSource8.scala,line-12 java.lang.Double.isInfinite(TestDouble.this.value()) +source-newSource8.scala,line-12 TestDouble.this.value() +source-newSource8.scala,line-13 scala.runtime.RichDouble.isNegInfinity$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-13 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-13 TestDouble.this.value() +source-newSource8.scala,line-14 scala.runtime.RichDouble.isPosInfinity$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-14 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-14 TestDouble.this.value() +source-newSource8.scala,line-16 TestDouble.this.value().toFloat() +source-newSource8.scala,line-16 TestDouble.this.value() +source-newSource8.scala,line-17 TestDouble.this.value().toDouble() +source-newSource8.scala,line-17 TestDouble.this.value() +source-newSource8.scala,line-18 TestDouble.this.value().toLong() +source-newSource8.scala,line-18 TestDouble.this.value() +source-newSource8.scala,line-19 TestDouble.this.value().toInt() +source-newSource8.scala,line-19 TestDouble.this.value() +source-newSource8.scala,line-20 TestDouble.this.value().toShort() +source-newSource8.scala,line-20 TestDouble.this.value() +source-newSource8.scala,line-21 TestDouble.this.value().toByte() +source-newSource8.scala,line-21 TestDouble.this.value() +source-newSource8.scala,line-23 scala.runtime.RichDouble.max$extension(scala.Predef.doubleWrapper(TestDouble.this.value()), TestDouble.this.value()) +source-newSource8.scala,line-23 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-23 TestDouble.this.value() +source-newSource8.scala,line-23 TestDouble.this.value() +source-newSource8.scala,line-24 scala.runtime.RichDouble.min$extension(scala.Predef.doubleWrapper(TestDouble.this.value()), TestDouble.this.value()) +source-newSource8.scala,line-24 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-24 TestDouble.this.value() +source-newSource8.scala,line-24 TestDouble.this.value() +source-newSource8.scala,line-25 scala.runtime.RichDouble.abs$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-25 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-25 TestDouble.this.value() +source-newSource8.scala,line-26 scala.runtime.RichDouble.signum$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-26 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-26 TestDouble.this.value() +source-newSource8.scala,line-27 scala.runtime.RichDouble.round$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-27 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-27 TestDouble.this.value() +source-newSource8.scala,line-28 scala.runtime.RichDouble.ceil$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-28 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-28 TestDouble.this.value() +source-newSource8.scala,line-29 scala.runtime.RichDouble.floor$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-29 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-29 TestDouble.this.value() +source-newSource8.scala,line-30 scala.runtime.RichDouble.toRadians$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-30 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-30 TestDouble.this.value() +source-newSource8.scala,line-31 scala.runtime.RichDouble.toDegrees$extension(scala.Predef.doubleWrapper(TestDouble.this.value())) +source-newSource8.scala,line-31 scala.Predef.doubleWrapper(TestDouble.this.value()) +source-newSource8.scala,line-31 TestDouble.this.value() +source-newSource8.scala,line-33 TestDouble.this.value().toByte() +source-newSource8.scala,line-33 TestDouble.this.value() +source-newSource8.scala,line-34 TestDouble.this.value().toShort() +source-newSource8.scala,line-34 TestDouble.this.value() +source-newSource8.scala,line-35 TestDouble.this.value().toInt() +source-newSource8.scala,line-35 TestDouble.this.value() +source-newSource8.scala,line-36 TestDouble.this.value().toLong() +source-newSource8.scala,line-36 TestDouble.this.value() +source-newSource8.scala,line-37 TestDouble.this.value().toFloat() +source-newSource8.scala,line-37 TestDouble.this.value() +source-newSource8.scala,line-38 TestDouble.this.value().toDouble() +source-newSource8.scala,line-38 TestDouble.this.value() + diff --git a/test/files/run/t12062.scala b/test/files/run/t12062.scala new file mode 100644 index 000000000000..95867d1ec8b4 --- /dev/null +++ b/test/files/run/t12062.scala @@ -0,0 +1,124 @@ +import scala.tools.partest._ +object Test extends CompilerTest { + import global._ + override def extraSettings = super.extraSettings + " -Yrangepos" + override def sources = List( + number("TestByte", "val value:Byte = 1.toByte"), + number("TestShort", "val value:Short = 1.toShort"), + number("TestInt", "val value:Int = 1.toInt"), + number("TestLong", "val value:Long = 1.toLong"), + primatives("TestBoolean", "val value: Boolean = true"), + primatives("TestChar", "val value:Char = 'x'"), + floating("TestFloat", "val value:Float = 1.toFloat"), + floating("TestDouble", "val value:Double = 1.toDouble") + ) + def primatives(className: String, decl: String) = { + s"""| + |class $className { + | $decl + | + | + | val a1 = value.toString + | val a2 = value.hashCode + | val a3 = value.## + |}""".stripMargin + + } + def number(className: String, decl: String) = { + s"""| + |class $className { + | $decl + | + | + | val a1 = value.toString + | val a2 = value.hashCode + | val a3 = value.## + | + | val c1 = value.floatValue + | val c2 = value.doubleValue + | val c3 = value.longValue + | val c4 = value.intValue + | val c5 = value.shortValue + | val c6 = value.byteValue + | + | val d1 = value max value + | val d2 = value min value + | val d3 = value.abs + | val d4 = value.signum + | + | val e1 = value.toByte + | val e2 = value.toShort + | val e3 = value.toInt + | val e4 = value.toLong + | val e5 = value.toFloat + | val e6 = value.toDouble + | + |}""".stripMargin + + } + def floating(className: String, decl: String) = { + 1.abs + s"""| + |class $className { + | $decl + | + | + | val a1 = value.toString + | val a2 = value.hashCode + | val a3 = value.## + | + | val b1 = value.isNaN + | val b2 = value.isInfinity + | val b3 = value.isInfinite + | val b4 = value.isNegInfinity + | val b5 = value.isPosInfinity + | + | val c1 = value.floatValue + | val c2 = value.doubleValue + | val c3 = value.longValue + | val c4 = value.intValue + | val c5 = value.shortValue + | val c6 = value.byteValue + | + | val d1 = value max value + | val d2 = value min value + | val d3 = value.abs + | val d4 = value.signum + | val d5 = value.round + | val d6 = value.ceil + | val d7 = value.floor + | val d8 = value.toRadians + | val d9 = value.toDegrees + | + | val e1 = value.toByte + | val e2 = value.toShort + | val e3 = value.toInt + | val e4 = value.toLong + | val e5 = value.toFloat + | val e6 = value.toDouble + | + |}""".stripMargin + + } + def check(source: String, unit: CompilationUnit) { + //really we are checking for calls tht box things + //e.g. + // scala.Int.box + // doubletoDouble etc + // easest way to see this is to print all the efs, and that should show any references + println() + for (ClassDef(_, className, _, Template(_, _, stats)) <- unit.body) { + println(s"class $className") + for (stat <- stats; + t <- stat) { + t match { + case _: Apply => + val pos = t.pos + println(s"source-${pos.source.path},line-${pos.line} $t") + case _ => + } + } + } + println() + } +} diff --git a/test/files/run/t7569.check b/test/files/run/t7569.check index 98513c3ab209..5153e9d6a4e9 100644 --- a/test/files/run/t7569.check +++ b/test/files/run/t7569.check @@ -5,8 +5,7 @@ source-newSource1.scala,line-4,offset=67 A.super. source-newSource1.scala,line-4,offset=67 this source-newSource1.scala,line-3,offset=49 A.this.one source-newSource1.scala,line-3,offset=49 A.this -RangePosition(newSource1.scala, 55, 57, 65) scala.Int.box(1).toString() -RangePosition(newSource1.scala, 55, 57, 65) scala.Int.box(1).toString -RangePosition(newSource1.scala, 55, 55, 56) scala.Int.box(1) -NoPosition scala.Int.box -NoPosition scala.Int +RangePosition(newSource1.scala, 55, 57, 65) java.lang.Integer.toString(1) +source-newSource1.scala,line-3,offset=57 java.lang.Integer.toString +source-newSource1.scala,line-3,offset=57 java.lang.Integer +source-newSource1.scala,line-3,offset=57 java.lang diff --git a/test/junit/scala/runtime/BooleanBoxingTest.scala b/test/junit/scala/runtime/BooleanBoxingTest.scala new file mode 100644 index 000000000000..cea455dbf874 --- /dev/null +++ b/test/junit/scala/runtime/BooleanBoxingTest.scala @@ -0,0 +1,49 @@ +package scala.runtime + +import org.junit.Test +import org.junit.Assert._ + +import scala.tools.testkit.AllocationTest + +class BooleanBoxingTest extends SideEffectTest with AllocationTest { + val value = true + + @Test def hash1(): Unit = { + nonAllocating(value.hashCode()) + } + + @Test def hash2(): Unit = { + nonAllocating(value.##) + } + + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Boolean.toString(value), "", false) + assertEquals("true", exactAllocates(cost.min)(value.toString())) + } + + //check that any rewrites don't skip side effects + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.boolean2Boolean(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.boolean2Boolean(value).toString + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/ByteBoxingTest.scala b/test/junit/scala/runtime/ByteBoxingTest.scala new file mode 100644 index 000000000000..b4eec3c181de --- /dev/null +++ b/test/junit/scala/runtime/ByteBoxingTest.scala @@ -0,0 +1,115 @@ +package scala.runtime + +import org.junit.Assert._ +import org.junit.Test + +import scala.tools.testkit.AllocationTest + +class ByteBoxingTest extends SideEffectTest with AllocationTest { + val value: Byte = 127.toByte + + @Test def hash1(): Unit = { + nonAllocating(value.hashCode()) + } + + @Test def hash2(): Unit = { + nonAllocating(value.##) + } + + @Test def float(): Unit = { + assertEquals(value, nonAllocating(value.floatValue()), 0D) + } + @Test def double(): Unit = { + assertEquals(value, nonAllocating(value.doubleValue()), 0D) + } + @Test def long(): Unit = { + assertEquals(value, nonAllocating(value.longValue())) + } + @Test def int(): Unit = { + assertEquals(value, nonAllocating(value.intValue())) + } + @Test def short(): Unit = { + assertEquals(value, nonAllocating(value.shortValue())) + } + @Test def byte(): Unit = { + assertEquals(value, nonAllocating(value.byteValue())) + } + + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Byte.toString(value), "", false) + assertEquals("127", exactAllocates(cost.min)(value.toString())) + } + //check that any rewrites don't skip side effects + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).toString + checkSideEffected() + } + + @Test def float_SideEffect1(): Unit = { + {sideEffect(); value}.floatValue() + checkSideEffected() + } + @Test def float_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).floatValue() + checkSideEffected() + } + @Test def double_SideEffect1(): Unit = { + {sideEffect(); value}.doubleValue() + checkSideEffected() + } + @Test def double_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).doubleValue() + checkSideEffected() + } + @Test def long_SideEffect1(): Unit = { + {sideEffect(); value}.longValue() + checkSideEffected() + } + @Test def long_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).longValue() + checkSideEffected() + } + @Test def int_SideEffect1(): Unit = { + {sideEffect(); value}.intValue() + checkSideEffected() + } + @Test def int_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).intValue() + checkSideEffected() + } + @Test def short_SideEffect1(): Unit = { + {sideEffect(); value}.shortValue() + checkSideEffected() + } + @Test def short_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).shortValue() + checkSideEffected() + } + @Test def byte_SideEffect1(): Unit = { + {sideEffect(); value}.byteValue() + checkSideEffected() + } + @Test def byte_SideEffect2(): Unit = { + {sideEffect(); Predef}.byte2Byte(value).byteValue() + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/CharBoxingTest.scala b/test/junit/scala/runtime/CharBoxingTest.scala new file mode 100644 index 000000000000..a256a8fb8a97 --- /dev/null +++ b/test/junit/scala/runtime/CharBoxingTest.scala @@ -0,0 +1,49 @@ +package scala.runtime + +import org.junit.Assert._ +import org.junit.Test + +import scala.tools.testkit.AllocationTest + +class CharBoxingTest extends SideEffectTest with AllocationTest { + val value = 'x' + + @Test def hash1(): Unit = { + nonAllocating(value.hashCode()) + } + + @Test def hash2(): Unit = { + nonAllocating(value.##) + } + + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Character.toString(value), "", false) + assertEquals("x", exactAllocates(cost.min)(value.toString())) + } + + //check that any rewrites don't skip side effects + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.char2Character(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.char2Character(value).toString + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/DoubleBoxingTest.scala b/test/junit/scala/runtime/DoubleBoxingTest.scala new file mode 100644 index 000000000000..d424d8622b3b --- /dev/null +++ b/test/junit/scala/runtime/DoubleBoxingTest.scala @@ -0,0 +1,225 @@ +package scala.runtime + +import org.junit._ +import Assert._ + +import scala.tools.testkit.AllocationTest + +class DoubleBoxingTest extends SideEffectTest with AllocationTest { + val nan = Double.NaN + val value = 999D + val valueInt = 999 + + @Test def isNaN(): Unit = { + assertTrue(nonAllocating(nan.isNaN)) + assertFalse(nonAllocating(value.isNaN)) + } + @Test def isInfinity(): Unit = { + assertFalse(nonAllocating(value.isInfinity)) + } + @Test def isInfinite(): Unit = { + assertFalse(nonAllocating(value.isInfinite)) + } + @Test def isNegInfinity(): Unit = { + assertFalse(nonAllocating(value.isNegInfinity)) + } + @Test def isPosInfinity(): Unit = { + assertFalse(nonAllocating(value.isPosInfinity)) + } + @Test def float(): Unit = { + assertEquals(value, nonAllocating(value.floatValue()), 0D) + } + @Test def double(): Unit = { + assertEquals(value, nonAllocating(value.doubleValue()), 0D) + } + @Test def long(): Unit = { + assertEquals(valueInt, nonAllocating(value.longValue())) + } + @Test def int(): Unit = { + assertEquals(valueInt, nonAllocating(value.intValue())) + } + @Test def short(): Unit = { + assertEquals(valueInt, nonAllocating(value.shortValue())) + } + @Test def byte(): Unit = { + assertEquals(-25, nonAllocating(value.byteValue())) + } + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Double.toString(value), "", false) + assertEquals("999.0", exactAllocates(cost.min)(value.toString())) + } + @Test def hash1(): Unit = { + nonAllocating(value.##) + } + @Test def hash2(): Unit = { + nonAllocating(value.hashCode()) + } + @Test def max(): Unit = { + nonAllocating(value max value) + } + @Test def min(): Unit = { + nonAllocating(value min value) + } + @Test def abs(): Unit = { + nonAllocating(value.abs) + } + @deprecated("testing", "") + @Test def signum(): Unit = { + nonAllocating(value.signum) + } + @Test def round(): Unit = { + nonAllocating(value.round) + } + @Test def ceil(): Unit = { + nonAllocating(value.ceil) + } + @Test def floor(): Unit = { + nonAllocating(value.floor) + } + @Test def rad(): Unit = { + nonAllocating(value.toRadians) + } + @Test def deg(): Unit = { + nonAllocating(value.toDegrees) + } + @Test def to(): Unit = { + nonAllocating(value.toByte) + nonAllocating(value.toShort) + nonAllocating(value.toInt) + nonAllocating(value.toLong) + nonAllocating(value.toFloat) + nonAllocating(value.toDouble) + } + + //check that any rewrites don't skip side effects + @Test def isNaN_SideEffect(): Unit = { + {sideEffect(); value}.isNaN() + checkSideEffected() + } + @Test def isInfinity_SideEffect(): Unit = { + {sideEffect(); value}.isInfinity + checkSideEffected() + } + @Test def isInfinite_SideEffect(): Unit = { + {sideEffect(); value}.isInfinite() + checkSideEffected() + } + @Test def isNegInfinity_SideEffect(): Unit = { + {sideEffect(); value}.isNegInfinity + checkSideEffected() + } + @Test def isPosInfinity_SideEffect(): Unit = { + {sideEffect(); value}.isPosInfinity + checkSideEffected() + } + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).toString + checkSideEffected() + } + + @Test def float_SideEffect1(): Unit = { + {sideEffect(); value}.floatValue() + checkSideEffected() + } + @Test def float_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).floatValue() + checkSideEffected() + } + @Test def double_SideEffect1(): Unit = { + {sideEffect(); value}.doubleValue() + checkSideEffected() + } + @Test def double_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).doubleValue() + checkSideEffected() + } + @Test def long_SideEffect1(): Unit = { + {sideEffect(); value}.longValue() + checkSideEffected() + } + @Test def long_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).longValue() + checkSideEffected() + } + @Test def int_SideEffect1(): Unit = { + {sideEffect(); value}.intValue() + checkSideEffected() + } + @Test def int_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).intValue() + checkSideEffected() + } + @Test def short_SideEffect1(): Unit = { + {sideEffect(); value}.shortValue() + checkSideEffected() + } + @Test def short_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).shortValue() + checkSideEffected() + } + @Test def byte_SideEffect1(): Unit = { + {sideEffect(); value}.byteValue() + checkSideEffected() + } + @Test def byte_SideEffect2(): Unit = { + {sideEffect(); Predef}.double2Double(value).byteValue() + checkSideEffected() + } + + @Test def max_SideEffect1(): Unit = { + {sideEffect(); value} max value + checkSideEffected() + } + @Test def min_SideEffect1(): Unit = { + {sideEffect(); value} min value + checkSideEffected() + } + @Test def abs_SideEffect1(): Unit = { + {sideEffect(); value}.abs + checkSideEffected() + } + @deprecated("testing", "") + @Test def signum_SideEffect1(): Unit = { + {sideEffect(); value}.signum + checkSideEffected() + } + @Test def round_SideEffect1(): Unit = { + {sideEffect(); value}.round + checkSideEffected() + } + @Test def ceil_SideEffect1(): Unit = { + {sideEffect(); value}.ceil + checkSideEffected() + } + @Test def floor_SideEffect1(): Unit = { + {sideEffect(); value}.floor + checkSideEffected() + } + @Test def rad_SideEffect1(): Unit = { + {sideEffect(); value}.toRadians + checkSideEffected() + } + @Test def deg_SideEffect1(): Unit = { + {sideEffect(); value}.toDegrees + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/FloatBoxingTest.scala b/test/junit/scala/runtime/FloatBoxingTest.scala new file mode 100644 index 000000000000..73a3c2955fc5 --- /dev/null +++ b/test/junit/scala/runtime/FloatBoxingTest.scala @@ -0,0 +1,225 @@ +package scala.runtime + +import org.junit.Assert.{assertEquals, assertFalse, assertTrue} +import org.junit.Test + +import scala.tools.testkit.AllocationTest + +class FloatBoxingTest extends SideEffectTest with AllocationTest { + val nan = Float.NaN + val value = 12345F + val valueInt = 12345 + + @Test def isNaN(): Unit = { + assertTrue(nonAllocating(nan.isNaN)) + assertFalse(nonAllocating(value.isNaN)) + } + @Test def isInfinity(): Unit = { + assertFalse(nonAllocating(value.isInfinity)) + } + @Test def isInfinite(): Unit = { + assertFalse(nonAllocating(value.isInfinite)) + } + @Test def isNegInfinity(): Unit = { + assertFalse(nonAllocating(value.isNegInfinity)) + } + @Test def isPosInfinity(): Unit = { + assertFalse(nonAllocating(value.isPosInfinity)) + } + @Test def float(): Unit = { + assertEquals(value, nonAllocating(value.floatValue()), 0D) + } + @Test def double(): Unit = { + assertEquals(value, nonAllocating(value.doubleValue()), 0D) + } + @Test def long(): Unit = { + assertEquals(valueInt, nonAllocating(value.longValue())) + } + @Test def int(): Unit = { + assertEquals(valueInt, nonAllocating(value.intValue())) + } + @Test def short(): Unit = { + assertEquals(valueInt, nonAllocating(value.shortValue())) + } + @Test def byte(): Unit = { + assertEquals(57, nonAllocating(value.byteValue())) + } + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Double.toString(value), "", false) + assertEquals("12345.0", exactAllocates(cost.min)(value.toString())) + } + @Test def hash1(): Unit = { + nonAllocating(value.##) + } + @Test def hash2(): Unit = { + nonAllocating(value.hashCode()) + } + @Test def max(): Unit = { + nonAllocating(value max value) + } + @Test def min(): Unit = { + nonAllocating(value min value) + } + @Test def abs(): Unit = { + nonAllocating(value.abs) + } + @deprecated("testing", "") + @Test def signum(): Unit = { + nonAllocating(value.signum) + } + @Test def round(): Unit = { + nonAllocating(value.round) + } + @Test def ceil(): Unit = { + nonAllocating(value.ceil) + } + @Test def floor(): Unit = { + nonAllocating(value.floor) + } + @Test def rad(): Unit = { + nonAllocating(value.toRadians) + } + @Test def deg(): Unit = { + nonAllocating(value.toDegrees) + } + @Test def to(): Unit = { + nonAllocating(value.toByte) + nonAllocating(value.toShort) + nonAllocating(value.toInt) + nonAllocating(value.toLong) + nonAllocating(value.toFloat) + nonAllocating(value.toDouble) + } + + //check that any rewrites don't skip side effects + @Test def isNaN_SideEffect(): Unit = { + {sideEffect(); value}.isNaN() + checkSideEffected() + } + @Test def isInfinity_SideEffect(): Unit = { + {sideEffect(); value}.isInfinity + checkSideEffected() + } + @Test def isInfinite_SideEffect(): Unit = { + {sideEffect(); value}.isInfinite() + checkSideEffected() + } + @Test def isNegInfinity_SideEffect(): Unit = { + {sideEffect(); value}.isNegInfinity + checkSideEffected() + } + @Test def isPosInfinity_SideEffect(): Unit = { + {sideEffect(); value}.isPosInfinity + checkSideEffected() + } + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).toString + checkSideEffected() + } + + @Test def float_SideEffect1(): Unit = { + {sideEffect(); value}.floatValue() + checkSideEffected() + } + @Test def float_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).floatValue() + checkSideEffected() + } + @Test def double_SideEffect1(): Unit = { + {sideEffect(); value}.doubleValue() + checkSideEffected() + } + @Test def double_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).doubleValue() + checkSideEffected() + } + @Test def long_SideEffect1(): Unit = { + {sideEffect(); value}.longValue() + checkSideEffected() + } + @Test def long_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).longValue() + checkSideEffected() + } + @Test def int_SideEffect1(): Unit = { + {sideEffect(); value}.intValue() + checkSideEffected() + } + @Test def int_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).intValue() + checkSideEffected() + } + @Test def short_SideEffect1(): Unit = { + {sideEffect(); value}.shortValue() + checkSideEffected() + } + @Test def short_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).shortValue() + checkSideEffected() + } + @Test def byte_SideEffect1(): Unit = { + {sideEffect(); value}.byteValue() + checkSideEffected() + } + @Test def byte_SideEffect2(): Unit = { + {sideEffect(); Predef}.float2Float(value).byteValue() + checkSideEffected() + } + + @Test def max_SideEffect1(): Unit = { + {sideEffect(); value} max value + checkSideEffected() + } + @Test def min_SideEffect1(): Unit = { + {sideEffect(); value} min value + checkSideEffected() + } + @Test def abs_SideEffect1(): Unit = { + {sideEffect(); value}.abs + checkSideEffected() + } + @deprecated("testing", "") + @Test def signum_SideEffect1(): Unit = { + {sideEffect(); value}.signum + checkSideEffected() + } + @Test def round_SideEffect1(): Unit = { + {sideEffect(); value}.round + checkSideEffected() + } + @Test def ceil_SideEffect1(): Unit = { + {sideEffect(); value}.ceil + checkSideEffected() + } + @Test def floor_SideEffect1(): Unit = { + {sideEffect(); value}.floor + checkSideEffected() + } + @Test def rad_SideEffect1(): Unit = { + {sideEffect(); value}.toRadians + checkSideEffected() + } + @Test def deg_SideEffect1(): Unit = { + {sideEffect(); value}.toDegrees + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/IntBoxingTest.scala b/test/junit/scala/runtime/IntBoxingTest.scala new file mode 100644 index 000000000000..5048571bb018 --- /dev/null +++ b/test/junit/scala/runtime/IntBoxingTest.scala @@ -0,0 +1,116 @@ +package scala.runtime + +import org.junit.Assert._ +import org.junit.Test + +import scala.tools.testkit.AllocationTest + +class IntBoxingTest extends SideEffectTest with AllocationTest { + val value = 999999999 + + @Test def hash1(): Unit = { + nonAllocating(value.hashCode()) + } + + @Test def hash2(): Unit = { + nonAllocating(value.##) + } + + @Test def float(): Unit = { + nonAllocating(value.floatValue()) + } + @Test def double(): Unit = { + nonAllocating(value.doubleValue()) + } + @Test def long(): Unit = { + nonAllocating(value.longValue()) + } + @Test def int(): Unit = { + nonAllocating(value.intValue()) + } + @Test def short(): Unit = { + nonAllocating(value.shortValue()) + } + @Test def byte(): Unit = { + nonAllocating(value.byteValue()) + } + + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Integer.toString(value), "", false) + assertEquals("999999999", exactAllocates(cost.min)(value.toString())) + } + + //check that any rewrites don't skip side effects + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).toString + checkSideEffected() + } + + @Test def float_SideEffect1(): Unit = { + {sideEffect(); value}.floatValue() + checkSideEffected() + } + @Test def float_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).floatValue() + checkSideEffected() + } + @Test def double_SideEffect1(): Unit = { + {sideEffect(); value}.doubleValue() + checkSideEffected() + } + @Test def double_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).doubleValue() + checkSideEffected() + } + @Test def long_SideEffect1(): Unit = { + {sideEffect(); value}.longValue() + checkSideEffected() + } + @Test def long_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).longValue() + checkSideEffected() + } + @Test def int_SideEffect1(): Unit = { + {sideEffect(); value}.intValue() + checkSideEffected() + } + @Test def int_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).intValue() + checkSideEffected() + } + @Test def short_SideEffect1(): Unit = { + {sideEffect(); value}.shortValue() + checkSideEffected() + } + @Test def short_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).shortValue() + checkSideEffected() + } + @Test def byte_SideEffect1(): Unit = { + {sideEffect(); value}.byteValue() + checkSideEffected() + } + @Test def byte_SideEffect2(): Unit = { + {sideEffect(); Predef}.int2Integer(value).byteValue() + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/LongBoxingTest.scala b/test/junit/scala/runtime/LongBoxingTest.scala new file mode 100644 index 000000000000..cd945e7e211e --- /dev/null +++ b/test/junit/scala/runtime/LongBoxingTest.scala @@ -0,0 +1,115 @@ +package scala.runtime + +import org.junit.Assert._ +import org.junit.Test + +import scala.tools.testkit.AllocationTest + +class LongBoxingTest extends SideEffectTest with AllocationTest { + val value = 99999999999999L + + @Test def hash1(): Unit = { + nonAllocating(value.hashCode()) + } + + @Test def hash2(): Unit = { + nonAllocating(value.##) + } + + @Test def float(): Unit = { + nonAllocating(value.floatValue()) + } + @Test def double(): Unit = { + nonAllocating(value.doubleValue()) + } + @Test def long(): Unit = { + nonAllocating(value.longValue()) + } + @Test def int(): Unit = { + nonAllocating(value.intValue()) + } + @Test def short(): Unit = { + nonAllocating(value.shortValue()) + } + @Test def byte(): Unit = { + nonAllocating(value.byteValue()) + } + + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Long.toString(value), "", false) + assertEquals("99999999999999", exactAllocates(cost.min)(value.toString())) + } + //check that any rewrites don't skip side effects + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).toString + checkSideEffected() + } + + @Test def float_SideEffect1(): Unit = { + {sideEffect(); value}.floatValue() + checkSideEffected() + } + @Test def float_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).floatValue() + checkSideEffected() + } + @Test def double_SideEffect1(): Unit = { + {sideEffect(); value}.doubleValue() + checkSideEffected() + } + @Test def double_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).doubleValue() + checkSideEffected() + } + @Test def long_SideEffect1(): Unit = { + {sideEffect(); value}.longValue() + checkSideEffected() + } + @Test def long_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).longValue() + checkSideEffected() + } + @Test def int_SideEffect1(): Unit = { + {sideEffect(); value}.intValue() + checkSideEffected() + } + @Test def int_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).intValue() + checkSideEffected() + } + @Test def short_SideEffect1(): Unit = { + {sideEffect(); value}.shortValue() + checkSideEffected() + } + @Test def short_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).shortValue() + checkSideEffected() + } + @Test def byte_SideEffect1(): Unit = { + {sideEffect(); value}.byteValue() + checkSideEffected() + } + @Test def byte_SideEffect2(): Unit = { + {sideEffect(); Predef}.long2Long(value).byteValue() + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/ShortBoxingTest.scala b/test/junit/scala/runtime/ShortBoxingTest.scala new file mode 100644 index 000000000000..b3b6669650f8 --- /dev/null +++ b/test/junit/scala/runtime/ShortBoxingTest.scala @@ -0,0 +1,115 @@ +package scala.runtime + +import org.junit.Assert._ +import org.junit.Test + +import scala.tools.testkit.AllocationTest + +class ShortBoxingTest extends SideEffectTest with AllocationTest { + val value: Short = 999.toShort + + @Test def hash1(): Unit = { + nonAllocating(value.hashCode()) + } + + @Test def hash2(): Unit = { + nonAllocating(value.##) + } + + @Test def float(): Unit = { + nonAllocating(value.floatValue()) + } + @Test def double(): Unit = { + nonAllocating(value.doubleValue()) + } + @Test def long(): Unit = { + nonAllocating(value.longValue()) + } + @Test def int(): Unit = { + nonAllocating(value.intValue()) + } + @Test def short(): Unit = { + nonAllocating(value.shortValue()) + } + @Test def byte(): Unit = { + nonAllocating(value.byteValue()) + } + + @Test def str(): Unit = { + val cost = allocationInfo(java.lang.Short.toString(value), "", false) + assertEquals("999", exactAllocates(cost.min)(value.toString())) + } + //check that any rewrites don't skip side effects + @Test def hash1_SideEffect1(): Unit = { + {sideEffect(); value}.hashCode() + checkSideEffected() + } + @Test def hash1_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).hashCode() + checkSideEffected() + } + + @Test def hash2_SideEffect(): Unit = { + {sideEffect(); value}.## + checkSideEffected() + } + + @Test def str_SideEffect1(): Unit = { + {sideEffect(); value}.toString + checkSideEffected() + } + + @Test def str_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).toString + checkSideEffected() + } + + @Test def float_SideEffect1(): Unit = { + {sideEffect(); value}.floatValue() + checkSideEffected() + } + @Test def float_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).floatValue() + checkSideEffected() + } + @Test def double_SideEffect1(): Unit = { + {sideEffect(); value}.doubleValue() + checkSideEffected() + } + @Test def double_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).doubleValue() + checkSideEffected() + } + @Test def long_SideEffect1(): Unit = { + {sideEffect(); value}.longValue() + checkSideEffected() + } + @Test def long_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).longValue() + checkSideEffected() + } + @Test def int_SideEffect1(): Unit = { + {sideEffect(); value}.intValue() + checkSideEffected() + } + @Test def int_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).intValue() + checkSideEffected() + } + @Test def short_SideEffect1(): Unit = { + {sideEffect(); value}.shortValue() + checkSideEffected() + } + @Test def short_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).shortValue() + checkSideEffected() + } + @Test def byte_SideEffect1(): Unit = { + {sideEffect(); value}.byteValue() + checkSideEffected() + } + @Test def byte_SideEffect2(): Unit = { + {sideEffect(); Predef}.short2Short(value).byteValue() + checkSideEffected() + } +} diff --git a/test/junit/scala/runtime/SideEffectTest.scala b/test/junit/scala/runtime/SideEffectTest.scala new file mode 100644 index 000000000000..e262a826d97b --- /dev/null +++ b/test/junit/scala/runtime/SideEffectTest.scala @@ -0,0 +1,18 @@ +package scala.runtime + +import org.junit.Assert._ + +trait SideEffectTest { + + private var affected = false + + def sideEffect() = { + assertFalse(affected) + affected = true + } + + def checkSideEffected(): Unit = { + assertTrue(affected) + } + +}