Skip to content
Permalink
Browse files

Pending and passing tests.

  Move now-passing SI-963 test into neg.
  Test for partial specialization.
  Pending test for SI-5008.
  Pending test for SI-4649.
  Abstract array type test.
  • Loading branch information
paulp committed May 11, 2012
1 parent 0d7952f commit 402b5e4a1341ef4549b7e0979f9c5afc06f47315
@@ -0,0 +1,6 @@
t963b.scala:25: error: type mismatch;
found : B.type
required: AnyRef{val y: A}
B.f(B)
^
one error found
@@ -5,8 +5,8 @@ trait A {
}

object B {
def f(x : { val y : A }) { x.y.v = x.y.v }
def f(x : { val y : A }) { x.y.v = x.y.v }

var a : A = _
var b : Boolean = false
def y : A = {
@@ -21,6 +21,6 @@ object B {
}
}

object Test extends Application {
object Test extends App {
B.f(B)
}
@@ -0,0 +1,11 @@
trait Foo {
type Repr <: String
def f2(x: Repr) = x.length
}
trait Fooz[Repr <: Array[_]] {
def f0(x: Repr) = x.length
}

trait Bar[Repr <: List[_]] extends Foo with Fooz[Array[Int]] {
def f1(x: Repr) = x.length
}
@@ -0,0 +1,165 @@
// These are members of class bar.C, completely unrelated to class foo.A.
// The types shown below include types defined within foo.A which are:
//
// - qualified private
// - qualified protected
// - object protected
//
// val a : foo.A = { /* compiled code */ }
// val xprot1 : java.lang.Object with foo.A.FooProt1 = { /* compiled code */ }
// val xprot2 : java.lang.Object with foo.A.FooProt2 = { /* compiled code */ }
// val xprot3 : java.lang.Object with foo.A.FooProt3 = { /* compiled code */ }
// val xprot4 : java.lang.Object with foo.A.FooProt4 = { /* compiled code */ }
// val xpriv3 : java.lang.Object with foo.A.FooPriv3 = { /* compiled code */ }
// val xpriv4 : java.lang.Object with foo.A.FooPriv4 = { /* compiled code */ }
//
// Indeed it will tell me a type which I cannot access:
//
// scala> new bar.C
// res0: bar.C = bar.C@1339a0dc
//
// scala> res0.xpriv3
// res1: java.lang.Object with res0.a.FooPriv3 = bar.C$$anon$29@39556aec
//
// scala> new res0.a.FooPriv3
// <console>:9: error: trait FooPriv3 in class A cannot be accessed in foo.A
// new res0.a.FooPriv3
// ^
// Looking at how the compiler prints the types of those vals, one
// develops a suspicion how some of it is being allowed:
//
// val xpriv4: C.this.a.FooPriv4
// val xpriv3: C.this.a.FooPriv3
// val xprot4: C.this.a.FooProt4
// val xprot3: C.this.a.FooProt3
// val xprot2: C.this.a.FooProt2
// val xprot1: C.this.a.FooProt1
//
// That is, "this" is in the prefix somewhere, it's just not a "this"
// which has any bearing.

package foo {
class A {
trait Foo

protected trait FooProt1
protected[this] trait FooProt2
protected[foo] trait FooProt3
protected[A] trait FooProt4

private trait FooPriv1
private[this] trait FooPriv2
private[foo] trait FooPriv3
private[A] trait FooPriv4

type BarProt1 = FooProt1
type BarProt2 = FooProt2
type BarProt3 = FooProt3
type BarProt4 = FooProt4

// type BarPriv1 = FooPriv1
// type BarPriv2 = FooPriv2
type BarPriv3 = FooPriv3
type BarPriv4 = FooPriv4

def fprot1(x: FooProt1) = x
def fprot2(x: FooProt2) = x
def fprot3(x: FooProt3) = x
def fprot4(x: FooProt4) = x

// def fpriv1(x: FooPriv1) = x
// def fpriv2(x: FooPriv2) = x
def fpriv3(x: FooPriv3) = x
def fpriv4(x: FooPriv4) = x

val yprot1 = new FooProt1 { }
val yprot2 = new FooProt2 { }
val yprot3 = new FooProt3 { }
val yprot4 = new FooProt4 { }

// val ypriv1 = new FooPriv1 { }
// val ypriv2 = new FooPriv2 { }
val ypriv3 = new FooPriv3 { }
val ypriv4 = new FooPriv4 { }

def fpriv_alt1(x: FooPriv1) = 0 // !!! isn't the private type now in the signature of the (public) method?
def fpriv_alt2(x: FooPriv2) = 0 // !!! isn't the private[this] type now in the signature of the (public) method?
}
// Same package, subclass
class B extends A {
val xprot1 = new BarProt1 { }
val xprot2 = new BarProt2 { }
val xprot3 = new BarProt3 { }
val xprot4 = new BarProt4 { }

// val xpriv1 = new BarPriv1 { }
// val xpriv2 = new BarPriv2 { }
val xpriv3 = new BarPriv3 { }
val xpriv4 = new BarPriv4 { }

override def fprot1(x: BarProt1) = x
override def fprot2(x: BarProt2) = x
override def fprot3(x: BarProt3) = x
override def fprot4(x: BarProt4) = x

// override def fpriv1(x: BarPriv1) = x
// override def fpriv2(x: BarPriv2) = x
override def fpriv3(x: BarPriv3) = x
override def fpriv4(x: BarPriv4) = x
}
// Same package, unrelated class
class C {
val a = new A
import a._

val xprot1 = new BarProt1 { }
val xprot2 = new BarProt2 { }
val xprot3 = new BarProt3 { }
val xprot4 = new BarProt4 { }

// val xpriv1 = new BarPriv1 { }
// val xpriv2 = new BarPriv2 { }
val xpriv3 = new BarPriv3 { }
val xpriv4 = new BarPriv4 { }
}
}

package bar {
// Different package, subclass
class B extends foo.A {
val xprot1 = new BarProt1 { }
val xprot2 = new BarProt2 { }
val xprot3 = new BarProt3 { }
val xprot4 = new BarProt4 { }

// val xpriv1 = new BarPriv1 { }
// val xpriv2 = new BarPriv2 { }
val xpriv3 = new BarPriv3 { }
val xpriv4 = new BarPriv4 { }

override def fprot1(x: BarProt1) = x
override def fprot2(x: BarProt2) = x
override def fprot3(x: BarProt3) = x
override def fprot4(x: BarProt4) = x

// override def fpriv1(x: BarPriv1) = x
// override def fpriv2(x: BarPriv2) = x
override def fpriv3(x: BarPriv3) = x
override def fpriv4(x: BarPriv4) = x
}
// Different package, unrelated class
class C {
val a = new foo.A
import a._

val xprot1 = new BarProt1 { }
val xprot2 = new BarProt2 { }
val xprot3 = new BarProt3 { }
val xprot4 = new BarProt4 { }

// val xpriv1 = new BarPriv1 { }
// val xpriv2 = new BarPriv2 { }
val xpriv3 = new BarPriv3 { }
val xpriv4 = new BarPriv4 { }
}
}
@@ -0,0 +1 @@
-Xfatal-warnings
@@ -0,0 +1,6 @@
object Test {
// @annotation.tailrec
def lazyFilter[E](s: Stream[E], p: E => Boolean): Stream[E] = s match {
case h #:: t => if (p(h)) h #:: lazyFilter(t, p) else lazyFilter(t, p)
}
}
@@ -0,0 +1,13 @@
Fn$mcII$sp
Fn$mcLI$sp
Fn$mcLI$sp
Fn$mcIL$sp
Fn
Fn
Fn$mcIL$sp
Fn
Fn
Fn3
Fn3$mcLIDF$sp
Fn3$mcBIDF$sp
Fn3
@@ -0,0 +1,31 @@
class Fn[@specialized(Int, AnyRef) -T, @specialized(Int, AnyRef) +R] {
override def toString = getClass.getName
}

class Fn3[
@specialized(Int, AnyRef) -T1,
@specialized(Double, AnyRef) -T2,
@specialized(Float) -T3,
@specialized(Byte, AnyRef) +R
] {
override def toString = getClass.getName
}

object Test {
def main(args: Array[String]): Unit = {
println(new Fn[Int, Int])
println(new Fn[Int, Byte])
println(new Fn[Int, AnyRef])
println(new Fn[Byte, Int])
println(new Fn[Byte, Byte])
println(new Fn[Byte, AnyRef])
println(new Fn[AnyRef, Int])
println(new Fn[AnyRef, Byte])
println(new Fn[AnyRef, AnyRef])

println(new Fn3[Int, Int, Int, Int])
println(new Fn3[Int, Double, Float, Int])
println(new Fn3[Int, Double, Float, Byte])
println(new Fn3[AnyRef, Double, AnyRef, Int])
}
}

0 comments on commit 402b5e4

Please sign in to comment.
You can’t perform that action at this time.