New facility: TypeDestructurers.

Would prefer to bake a little longer, but, scala days.

More elaboration to come.

6 files changed, 386 insertions, 7 deletions

diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check
index b9ff6afa2b..292d2fc4cb 100644
--- a/test/files/jvm/interpreter.check
+++ b/test/files/jvm/interpreter.check
@@ -316,9 +316,8 @@ scala> /*
   */
 */
 
-scala> 
 
-scala> 
+You typed two blank lines.  Starting a new command.
 
 scala> // multi-line string
 
@@ -326,7 +325,7 @@ scala> """
 hello
 there
 """
-res9: String = 
+res12: String = 
 "
 hello
 there
diff --git a/test/files/run/repl-colon-type.check b/test/files/run/repl-colon-type.check
index 66c2fcc77f..cb0b9a6c8b 100644
--- a/test/files/run/repl-colon-type.check
+++ b/test/files/run/repl-colon-type.check
@@ -7,6 +7,12 @@ scala> :type List[1, 2, 3]
 <console>:2: error: identifier expected but integer literal found.
        List[1, 2, 3]
             ^
+<console>:3: error: ']' expected but '}' found.
+       }
+       ^
+<console>:1: error: identifier expected but integer literal found.
+       List[1, 2, 3]
+            ^
 
 
 scala> :type List(1, 2, 3)
@@ -25,7 +31,7 @@ scala> :type def f[T >: Null, U <: String](x: T, y: U) = Set(x, y)
 [T >: Null, U <: String](x: T, y: U)scala.collection.immutable.Set[Any]
 
 scala> :type def x = 1 ; def bar[T >: Null <: AnyRef](xyz: T) = 5
-[T >: Null <: AnyRef](xyz: T)Int
+=> Int <and> [T >: Null <: AnyRef](xyz: T)Int
 
 scala> 
 
@@ -39,10 +45,19 @@ scala> :type lazy val f = 5
 Int
 
 scala> :type protected lazy val f = 5
-Int
+<console>:2: error: illegal start of statement (no modifiers allowed here)
+       protected lazy val f = 5
+       ^
+<console>:5: error: lazy value f cannot be accessed in object $iw
+ Access to protected value f not permitted because
+ enclosing object $eval in package $line19 is not a subclass of 
+ object $iw where target is defined
+  lazy val $result = `f`
+                                           ^
+
 
 scala> :type def f = 5
-Int
+=> Int
 
 scala> :type def f() = 5
 ()Int
@@ -54,4 +69,156 @@ scala> :type def g[T](xs: Set[_ <: T]) = Some(xs.head)
 
 scala> 
 
+scala> // verbose!
+
+scala> :type -v List(1,2,3) filter _
+// Type signature
+(Int => Boolean) => List[Int]
+
+// Internal Type structure
+TypeRef(
+  TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+  args = List(
+    TypeRef(
+      TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+      args = List(
+        TypeRef(TypeSymbol(final class Int extends AnyVal))
+        TypeRef(TypeSymbol(final class Boolean extends AnyVal))
+      )
+    )
+    TypeRef(
+      TypeSymbol(
+        sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A,List] with LinearSeqOptimized[A,List[A]]
+        
+      )
+      args = List(
+        TypeRef(TypeSymbol(final class Int extends AnyVal))
+      )
+    )
+  )
+)
+
+scala> :type -v def f[T >: Null, U <: String](x: T, y: U) = Set(x, y)
+// Type signature
+[T >: Null, U <: String](x: T, y: U)scala.collection.immutable.Set[Any]
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T >: Null), TypeParam(U <: String))
+  resultType = MethodType(
+    params = List(TermSymbol(x: T), TermSymbol(y: U))
+    resultType = TypeRef(
+      TypeSymbol(
+        abstract trait Set[A] extends Iterable[A] with Set[A] with GenericSetTemplate[A,scala.collection.immutable.Set] with SetLike[A,scala.collection.immutable.Set[A]] with Parallelizable[A,scala.collection.parallel.immutable.ParSet[A]]
+        
+      )
+      args = List(TypeRef(TypeSymbol(abstract class Any extends )))
+    )
+  )
+)
+
+scala> :type -v def x = 1 ; def bar[T >: Null <: AnyRef](xyz: T) = 5
+// Type signature
+=> Int <and> [T >: Null <: AnyRef](xyz: T)Int
+
+// Internal Type structure
+OverloadedType(
+  alts = List(
+    NullaryMethodType(
+      TypeRef(TypeSymbol(final class Int extends AnyVal))
+    )
+    PolyType(
+      typeParams = List(TypeParam(T >: Null <: AnyRef))
+      resultType = MethodType(
+        params = List(TermSymbol(xyz: T))
+        resultType = TypeRef(
+          TypeSymbol(final class Int extends AnyVal)
+        )
+      )
+    )
+  )
+)
+
+scala> :type -v Nil.combinations _
+// Type signature
+Int => Iterator[List[Nothing]]
+
+// Internal Type structure
+TypeRef(
+  TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+  args = List(
+    TypeRef(TypeSymbol(final class Int extends AnyVal))
+    TypeRef(
+      TypeSymbol(
+        abstract trait Iterator[+A] extends TraversableOnce[A]
+      )
+      args = List(
+        TypeRef(
+          TypeSymbol(
+            sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A,List] with LinearSeqOptimized[A,List[A]]
+            
+          )
+          args = List(
+            TypeRef(
+              TypeSymbol(final abstract class Nothing extends Any)
+            )
+          )
+        )
+      )
+    )
+  )
+)
+
+scala> :type -v def f[T <: AnyVal] = List[T]().combinations _
+// Type signature
+[T <: AnyVal]=> Int => Iterator[List[T]]
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T <: AnyVal))
+  resultType = NullaryMethodType(
+    TypeRef(
+      TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+      args = List(
+        TypeRef(TypeSymbol(final class Int extends AnyVal))
+        TypeRef(
+          TypeSymbol(
+            abstract trait Iterator[+A] extends TraversableOnce[A]
+          )
+          args = List(
+            TypeRef(
+              TypeSymbol(
+                sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A,List] with LinearSeqOptimized[A,List[A]]
+                
+              )
+              args = List(TypeParamTypeRef(TypeParam(T <: AnyVal)))
+            )
+          )
+        )
+      )
+    )
+  )
+)
+
+scala> :type -v def f[T, U >: T](x: T, y: List[U]) = x :: y
+// Type signature
+[T, U >: T](x: T, y: List[U])List[U]
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T), TypeParam(U >: T))
+  resultType = MethodType(
+    params = List(TermSymbol(x: T), TermSymbol(y: List[U]))
+    resultType = TypeRef(
+      TypeSymbol(
+        sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A,List] with LinearSeqOptimized[A,List[A]]
+        
+      )
+      args = List(TypeParamTypeRef(TypeParam(U >: T)))
+    )
+  )
+)
+
+scala> 
+
 scala> 
diff --git a/test/files/run/repl-colon-type.scala b/test/files/run/repl-colon-type.scala
index 39ab580d2a..c055b215c2 100644
--- a/test/files/run/repl-colon-type.scala
+++ b/test/files/run/repl-colon-type.scala
@@ -18,6 +18,14 @@ object Test extends ReplTest {
     |:type def f() = 5
     |
     |:type def g[T](xs: Set[_ <: T]) = Some(xs.head)
+    |
+    |// verbose!
+    |:type -v List(1,2,3) filter _
+    |:type -v def f[T >: Null, U <: String](x: T, y: U) = Set(x, y)
+    |:type -v def x = 1 ; def bar[T >: Null <: AnyRef](xyz: T) = 5
+    |:type -v Nil.combinations _
+    |:type -v def f[T <: AnyVal] = List[T]().combinations _
+    |:type -v def f[T, U >: T](x: T, y: List[U]) = x :: y
   """.stripMargin
 }
 
diff --git a/test/files/run/repl-power.check b/test/files/run/repl-power.check
index e439a2a7f4..1e7b6f0cd8 100644
--- a/test/files/run/repl-power.check
+++ b/test/files/run/repl-power.check
@@ -14,7 +14,6 @@ scala> global.emptyValDef  // "it is imported twice in the same scope by ..."
 res0: $r.global.emptyValDef.type = private val _ = _
 
 scala> val tp = ArrayClass[scala.util.Random]    // magic with manifests
-warning: there were 2 feature warnings; re-run with -feature for details
 tp: $r.global.Type = Array[scala.util.Random]
 
 scala> tp.memberType(Array_apply)                // evidence
diff --git a/test/files/run/repl-type-verbose.check b/test/files/run/repl-type-verbose.check
new file mode 100644
index 0000000000..103ac3e64d
--- /dev/null
+++ b/test/files/run/repl-type-verbose.check
@@ -0,0 +1,186 @@
+Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> 
+
+scala> // verbose!
+
+scala> :type -v def f = 5
+// Type signature
+=> Int
+
+// Internal Type structure
+NullaryMethodType(
+  TypeRef(TypeSymbol(final class Int extends AnyVal))
+)
+
+scala> :type -v def f() = 5
+// Type signature
+()Int
+
+// Internal Type structure
+NullaryMethodType(
+  resultType = TypeRef(TypeSymbol(final class Int extends AnyVal))
+)
+
+scala> :type -v def f[T] = 5
+// Type signature
+[T]=> Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T))
+  resultType = NullaryMethodType(
+    TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T >: Null] = 5
+// Type signature
+[T >: Null]=> Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T >: Null))
+  resultType = NullaryMethodType(
+    TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T <: String] = 5
+// Type signature
+[T <: String]=> Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T <: String))
+  resultType = NullaryMethodType(
+    TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T]() = 5
+// Type signature
+[T]()Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T))
+  resultType = NullaryMethodType(
+    resultType = TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T, U]() = 5
+// Type signature
+[T, U]()Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T), TypeParam(U))
+  resultType = NullaryMethodType(
+    resultType = TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T, U]()() = 5
+// Type signature
+[T, U]()()Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T), TypeParam(U))
+  resultType = NullaryMethodType(
+    resultType = NullaryMethodType(
+      resultType = TypeRef(
+        TypeSymbol(final class Int extends AnyVal)
+      )
+    )
+  )
+)
+
+scala> :type -v def f[T, U <: T] = 5
+// Type signature
+[T, U <: T]=> Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T), TypeParam(U <: T))
+  resultType = NullaryMethodType(
+    TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T, U <: T](x: T)(y: U) = 5
+// Type signature
+[T, U <: T](x: T)(y: U)Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T), TypeParam(U <: T))
+  resultType = MethodType(
+    params = List(TermSymbol(x: T))
+    resultType = MethodType(
+      params = List(TermSymbol(y: U))
+      resultType = TypeRef(
+        TypeSymbol(final class Int extends AnyVal)
+      )
+    )
+  )
+)
+
+scala> :type -v def f[T: Ordering] = 5
+// Type signature
+[T](implicit evidence$1: Ordering[T])Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T))
+  resultType = MethodType(
+    params = List(TermSymbol(implicit evidence$1: Ordering[T]))
+    resultType = TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> :type -v def f[T: Ordering] = implicitly[Ordering[T]]
+// Type signature
+[T](implicit evidence$1: Ordering[T])Ordering[T]
+
+// Internal Type structure
+PolyType(
+  typeParams = List(TypeParam(T))
+  resultType = MethodType(
+    params = List(TermSymbol(implicit evidence$1: Ordering[T]))
+    resultType = AliasTypeRef(
+      Alias(type Ordering[T] = scala.math.Ordering[T])
+      args = List(TypeParamTypeRef(TypeParam(T)))
+      normalize = TypeRef(
+        TypeSymbol(
+          abstract trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable
+          
+        )
+        args = List(TypeParamTypeRef(TypeParam(T)))
+      )
+    )
+  )
+)
+
+scala> :type -v def f[T <: { type Bippy = List[Int] ; def g(): Bippy }] = 5
+// Type signature
+[T <: AnyRef{type Bippy = List[Int]; def g(): this.Bippy}]=> Int
+
+// Internal Type structure
+PolyType(
+  typeParams = List(
+    TypeParam(
+      T <: AnyRef{type Bippy = List[Int]; def g(): this.Bippy}
+    )
+  )
+  resultType = NullaryMethodType(
+    TypeRef(TypeSymbol(final class Int extends AnyVal))
+  )
+)
+
+scala> 
+
+scala> 
diff --git a/test/files/run/repl-type-verbose.scala b/test/files/run/repl-type-verbose.scala
new file mode 100644
index 0000000000..10c390550a
--- /dev/null
+++ b/test/files/run/repl-type-verbose.scala
@@ -0,0 +1,20 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  def code = """
+    |// verbose!
+    |:type -v def f = 5
+    |:type -v def f() = 5
+    |:type -v def f[T] = 5
+    |:type -v def f[T >: Null] = 5
+    |:type -v def f[T <: String] = 5
+    |:type -v def f[T]() = 5
+    |:type -v def f[T, U]() = 5
+    |:type -v def f[T, U]()() = 5
+    |:type -v def f[T, U <: T] = 5
+    |:type -v def f[T, U <: T](x: T)(y: U) = 5
+    |:type -v def f[T: Ordering] = 5
+    |:type -v def f[T: Ordering] = implicitly[Ordering[T]]
+    |:type -v def f[T <: { type Bippy = List[Int] ; def g(): Bippy }] = 5
+  """.stripMargin
+}