blob: 1cc554264ce414858b61e4464d1b1430c7d75a73 (
plain) (
tree)
|
|
// alias
trait Thingy
class Gramps
// sibling classes that extend a case class
case class Thing(i: Int) extends Gramps
class ThingOne(x:Int) extends Thing(x)
class ThingTwo(y:Int) extends Thing(y) with Thingy
final class ThingThree(z:Int) extends Thing(z)
// not case cousin
class Cousin extends Gramps
class SimpleParent
case class Simple() extends SimpleParent
case object SimpleSibling extends SimpleParent
// value classes
final class ValueClass1(val value: Int) extends AnyVal
final class ValueClass2[T](val value: T) extends AnyVal
final case class ValueClass3(val value: Int) extends AnyVal
/* It's not possible to run partest without -deprecation.
* Since detecting the warnings requires a neg test with
* -Xfatal-warnings, and deprecation terminates the compile,
* we'll just comment out the nasty part. The point was
* just to show there's nothing special about a trait
* that extends a case class, which is only permitted
* (deprecatingly) by omitting the parens.
*
// common ancestor is something else
class AnyThing
case class SomeThing extends AnyThing // deprecation
class OtherThing extends AnyThing
// how you inherit caseness doesn't matter
trait InThing extends SomeThing
class MyThing extends InThing
*/
object Test {
def main(a: Array[String]): Unit = {
// nothing to do with Gavin
println(new Some(1) == new Some(1)) // OK, true
println(new Some(1) == None) // Should complain on type, was: spuriously complains on fresh object
println(Some(1) == new Thing(1)) // Should complain on type, was: spuriously complains on fresh object
val t1 = new ThingOne(11)
val t2: Thingy = new ThingTwo(11)
val t3 = new ThingTwo(11)
val t4 = new ThingThree(11)
val c = new Cousin
println(t1 == t2) // true, but apparently unrelated, a compromise warning
println(t4 == t2) // true, complains because ThingThree is final and Thingy not a subclass, stronger claim than unrelated
println(t2 == t3) // OK, two Thingy
println(t3 == t2) // ditto with case receiver
println(t3 == Some(1)) // false, warn on different cases
println(t1 == c) // should warn
// don't warn on fresh cases
println(new ThingOne(11) == t1) // OK, was: two cases not warnable on trunk
println(new ThingTwo(11) == t2) // true, was: spuriously complains on fresh object
println(new ThingOne(11) == t3) // two cases not warnable on trunk
println(new ThingTwo(11) == t3) // ditto
println(new Simple() == SimpleSibling) // like Some(1) == None, but needn't be final case
println(new ValueClass1(5) == new ValueClass1(5)) // ok
println(new ValueClass1(5) == 5) // bad
println(new ValueClass1(5) == (5: Any)) // ok, have to let it through
println(5 == new ValueClass1(5)) // bad
println((5: Any) == new ValueClass1(5) == (5: Any)) // ok
println(new ValueClass2("abc") == new ValueClass2("abc")) // ok
println(new ValueClass2("abc") == "abc") // bad
println(new ValueClass2(5) == new ValueClass1(5)) // bad - different value classes
println(ValueClass3(5) == new ValueClass3(5)) // ok
println(ValueClass3(5) == new ValueClass2(5)) // bad
println(ValueClass3(5) == 5) // bad
/*
val mine = new MyThing
val some = new SomeThing
val other = new OtherThing
println(mine == some) // OK, two Something
println(some == mine)
println(mine == other) // OK, two Anything?
println(mine == t1) // false
*/
}
}
|