Merge remote-tracking branch 'scala/2.10.x' into 2.10.0-wip

81 files changed, 1535 insertions, 215 deletions

diff --git a/src/compiler/scala/reflect/reify/utils/Extractors.scala b/src/compiler/scala/reflect/reify/utils/Extractors.scala
index b7206eda0e..b60d15c1d4 100644
--- a/src/compiler/scala/reflect/reify/utils/Extractors.scala
+++ b/src/compiler/scala/reflect/reify/utils/Extractors.scala
@@ -92,11 +92,18 @@ trait Extractors {
     Block(List(universeAlias, mirrorAlias), wrappee)
   }
 
+  // if we're reifying a MethodType, we can't use it as a type argument for TypeTag ctor
+  // http://groups.google.com/group/scala-internals/browse_thread/thread/2d7bb85bfcdb2e2
+  private def mkTarg(tpe: Type): Tree = (
+    if ((tpe eq null) || !isUseableAsTypeArg(tpe)) TypeTree(AnyTpe)
+    else TypeTree(tpe)
+  )
+
   object ReifiedTree {
     def apply(universe: Tree, mirror: Tree, symtab: SymbolTable, rtree: Tree, tpe: Type, rtpe: Tree, concrete: Boolean): Tree = {
       val tagFactory = if (concrete) nme.TypeTag else nme.WeakTypeTag
-      val tagCtor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), tagFactory), nme.apply), List(TypeTree(tpe)))
-      val exprCtor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), nme.Expr), nme.apply), List(TypeTree(tpe)))
+      val tagCtor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), tagFactory), nme.apply), List(mkTarg(tpe)))
+      val exprCtor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), nme.Expr), nme.apply), List(mkTarg(tpe)))
       val tagArgs = List(Ident(nme.MIRROR_SHORT), mkCreator(tpnme.REIFY_TYPECREATOR_PREFIX, symtab, rtpe))
       val unwrapped = Apply(Apply(exprCtor, List(Ident(nme.MIRROR_SHORT), mkCreator(tpnme.REIFY_TREECREATOR_PREFIX, symtab, rtree))), List(Apply(tagCtor, tagArgs)))
       mkWrapper(universe, mirror, unwrapped)
@@ -123,7 +130,7 @@ trait Extractors {
   object ReifiedType {
     def apply(universe: Tree, mirror: Tree, symtab: SymbolTable, tpe: Type, rtpe: Tree, concrete: Boolean) = {
       val tagFactory = if (concrete) nme.TypeTag else nme.WeakTypeTag
-      val ctor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), tagFactory), nme.apply), List(TypeTree(tpe)))
+      val ctor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), tagFactory), nme.apply), List(mkTarg(tpe)))
       val args = List(Ident(nme.MIRROR_SHORT), mkCreator(tpnme.REIFY_TYPECREATOR_PREFIX, symtab, rtpe))
       val unwrapped = Apply(ctor, args)
       mkWrapper(universe, mirror, unwrapped)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index eaee39d7e6..a7da857429 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -1750,7 +1750,7 @@ self =>
             in.nextToken()
             if (in.token == SUBTYPE || in.token == SUPERTYPE) wildcardType(start)
             else atPos(start) { Bind(tpnme.WILDCARD, EmptyTree) }
-          case IDENTIFIER if treeInfo.isVariableName(in.name) =>
+          case IDENTIFIER if nme.isVariableName(in.name) =>
             atPos(start) { Bind(identForType(), EmptyTree) }
           case _ =>
             typ()
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 4738ad8a38..f9eeb41e6d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -832,15 +832,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
      *
      * The contents of that attribute are determined by the `String[] exceptions` argument to ASM's ClassVisitor.visitMethod()
      * This method returns such list of internal names.
-     *
      */
-    def getExceptions(excs: List[AnnotationInfo]): List[String] = {
-      for (AnnotationInfo(tp, List(exc), _) <- excs.distinct if tp.typeSymbol == ThrowsClass)
-      yield {
-        val Literal(const) = exc
-        javaName(const.typeValue.typeSymbol)
-      }
-    }
+    def getExceptions(excs: List[AnnotationInfo]): List[String] =
+      for (ThrownException(exc) <- excs.distinct)
+      yield javaName(exc)
 
     /** Whether an annotation should be emitted as a Java annotation
      *   .initialize: if 'annot' is read from pickle, atp might be un-initialized
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 62c281b82f..cb6156c59c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -606,11 +606,10 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
       // put some random value; the actual number is determined at the end
       buf putShort 0xbaba.toShort
 
-      for (AnnotationInfo(tp, List(exc), _) <- excs.distinct if tp.typeSymbol == ThrowsClass) {
-        val Literal(const) = exc
+      for (ThrownException(exc) <- excs.distinct) {
         buf.putShort(
           cpool.addClass(
-            javaName(const.typeValue.typeSymbol)).shortValue)
+            javaName(exc)).shortValue)
         nattr += 1
       }
 
diff --git a/src/compiler/scala/tools/nsc/matching/Patterns.scala b/src/compiler/scala/tools/nsc/matching/Patterns.scala
index af77d3fe3f..40e520076a 100644
--- a/src/compiler/scala/tools/nsc/matching/Patterns.scala
+++ b/src/compiler/scala/tools/nsc/matching/Patterns.scala
@@ -21,7 +21,7 @@ trait Patterns extends ast.TreeDSL {
   import definitions._
   import CODE._
   import Debug._
-  import treeInfo.{ unbind, isStar, isVarPattern, isVariableName }
+  import treeInfo.{ unbind, isStar, isVarPattern }
 
   type PatternMatch       = MatchMatrix#PatternMatch
   private type PatternVar = MatrixContext#PatternVar
@@ -366,7 +366,7 @@ trait Patterns extends ast.TreeDSL {
     lazy val Select(qualifier, name) = select
     def pathSegments = getPathSegments(tree)
     def backticked: Option[String] = qualifier match {
-      case _: This if isVariableName(name)  => Some("`%s`".format(name))
+      case _: This if nme.isVariableName(name)  => Some("`%s`".format(name))
       case _                                => None
     }
     override def covers(sym: Symbol) = newMatchesPattern(sym, tree.tpe)
@@ -388,11 +388,11 @@ trait Patterns extends ast.TreeDSL {
     lazy val UnApply(unfn, args) = tree
     lazy val Apply(fn, _) = unfn
     lazy val MethodType(List(arg, _*), _) = fn.tpe
-    
+
     // Covers if the symbol matches the unapply method's argument type,
     // and the return type of the unapply is Some.
     override def covers(sym: Symbol) = newMatchesPattern(sym, arg.tpe)
-    
+
     // TODO: for alwaysCovers:
     //   fn.tpe.finalResultType.typeSymbol == SomeClass
 
@@ -451,7 +451,7 @@ trait Patterns extends ast.TreeDSL {
         (sym.tpe.baseTypeSeq exists (_ matchesPattern pattp))
       }
     }
-    
+
     def    sym  = tree.symbol
     def    tpe  = tree.tpe
     def isEmpty = tree.isEmpty
@@ -496,4 +496,4 @@ trait Patterns extends ast.TreeDSL {
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 5a3db26e30..d3a5cebea0 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -185,7 +185,7 @@ abstract class UnCurry extends InfoTransform
      *    try {
      *      body
      *    } catch {
-     *      case ex: NonLocalReturnControl[_] =>
+     *      case ex: NonLocalReturnControl[T @unchecked] =>
      *        if (ex.key().eq(key)) ex.value()
      *        else throw ex
      *    }
@@ -195,7 +195,8 @@ abstract class UnCurry extends InfoTransform
       localTyper typed {
         val extpe   = nonLocalReturnExceptionType(meth.tpe.finalResultType)
         val ex      = meth.newValue(nme.ex, body.pos) setInfo extpe
-        val pat     = gen.mkBindForCase(ex, NonLocalReturnControlClass, List(meth.tpe.finalResultType))
+        val argType = meth.tpe.finalResultType withAnnotation (AnnotationInfo marker UncheckedClass.tpe)
+        val pat     = gen.mkBindForCase(ex, NonLocalReturnControlClass, List(argType))
         val rhs = (
           IF   ((ex DOT nme.key)() OBJ_EQ Ident(key))
           THEN ((ex DOT nme.value)())
diff --git a/src/compiler/scala/tools/nsc/typechecker/Checkable.scala b/src/compiler/scala/tools/nsc/typechecker/Checkable.scala
new file mode 100644
index 0000000000..7e15cf91a7
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/typechecker/Checkable.scala
@@ -0,0 +1,284 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2012 LAMP/EPFL
+ * @author  Paul Phillips
+ */
+
+package scala.tools.nsc
+package typechecker
+
+import scala.collection.{ mutable, immutable }
+import scala.collection.mutable.ListBuffer
+import scala.util.control.ControlThrowable
+import symtab.Flags._
+import scala.annotation.tailrec
+import Checkability._
+
+/** On pattern matcher checkability:
+ *
+ *  Consider a pattern match of this form: (x: X) match { case _: P => }
+ *
+ *  There are four possibilities to consider:
+ *     [P1] X will always conform to P
+ *     [P2] x will never conform to P
+ *     [P3] X <: P if some runtime test is true
+ *     [P4] X cannot be checked against P
+ *
+ *  The first two cases correspond to those when there is enough
+ *  static information to say X <: P or that (x ∈ X) ⇒ (x ∉ P).
+ *  The fourth case includes unknown abstract types or structural
+ *  refinements appearing within a pattern.
+ *
+ *  The third case is the interesting one.  We designate another type, XR,
+ *  which is essentially the intersection of X and |P|, where |P| is
+ *  the erasure of P.  If XR <: P, then no warning is emitted.
+ *
+ *  Examples of how this info is put to use:
+ *  sealed trait A[T] ; class B[T] extends A[T]
+ *    def f(x: B[Int]) = x match { case _: A[Int] if true => }
+ *    def g(x: A[Int]) = x match { case _: B[Int] => }
+ *
+ *  `f` requires no warning because X=B[Int], P=A[Int], and B[Int] <:< A[Int].
+ *  `g` requires no warning because X=A[Int], P=B[Int], XR=B[Int], and B[Int] <:< B[Int].
+ *      XR=B[Int] because a value of type A[Int] which is tested to be a B can
+ *      only be a B[Int], due to the definition of B (B[T] extends A[T].)
+ *
+ *  This is something like asSeenFrom, only rather than asking what a type looks
+ *  like from the point of view of one of its base classes, we ask what it looks
+ *  like from the point of view of one of its subclasses.
+ */
+trait Checkable {
+  self: Analyzer =>
+
+  import global._
+  import definitions._
+  import CheckabilityChecker.{ isNeverSubType, isNeverSubClass }
+
+  /** The applied type of class 'to' after inferring anything
+   *  possible from the knowledge that 'to' must also be of the
+   *  type given in 'from'.
+   */
+  def propagateKnownTypes(from: Type, to: Symbol): Type = {
+    def tparams  = to.typeParams
+    val tvars    = tparams map (p => TypeVar(p))
+    val tvarType = appliedType(to, tvars: _*)
+    val bases    = from.baseClasses filter (to.baseClasses contains _)
+
+    bases foreach { bc =>
+      val tps1 = (from baseType bc).typeArgs
+      val tps2 = (tvarType baseType bc).typeArgs
+      (tps1, tps2).zipped foreach (_ =:= _)
+      // Alternate, variance respecting formulation causes
+      // neg/unchecked3.scala to fail (abstract types).  TODO -
+      // figure it out. It seems there is more work to do if I
+      // allow for variance, because the constraints accumulate
+      // as bounds and "tvar.instValid" is false.
+      //
+      // foreach3(tps1, tps2, bc.typeParams)((tp1, tp2, tparam) =>
+      //   if (tparam.initialize.isCovariant) tp1 <:< tp2
+      //   else if (tparam.isContravariant) tp2 <:< tp1
+      //   else tp1 =:= tp2
+      // )
+    }
+
+    val resArgs = tparams zip tvars map {
+      case (_, tvar) if tvar.instValid => tvar.constr.inst
+      case (tparam, _)                 => tparam.tpe
+    }
+    appliedType(to, resArgs: _*)
+  }
+
+  private def isUnwarnableTypeArgSymbol(sym: Symbol) = (
+       sym.isTypeParameter                     // dummy
+    || (sym.name.toTermName == nme.WILDCARD)   // _
+    || nme.isVariableName(sym.name)            // type variable
+  )
+  private def isUnwarnableTypeArg(arg: Type) = (
+       uncheckedOk(arg)                                 // @unchecked T
+    || isUnwarnableTypeArgSymbol(arg.typeSymbolDirect)  // has to be direct: see pos/t1439
+  )
+  private def uncheckedOk(tp: Type) = tp hasAnnotation UncheckedClass
+
+  private def typeArgsInTopLevelType(tp: Type): List[Type] = {
+    val tps = tp match {
+      case RefinedType(parents, _)              => parents flatMap typeArgsInTopLevelType
+      case TypeRef(_, ArrayClass, arg :: Nil)   => typeArgsInTopLevelType(arg)
+      case TypeRef(pre, sym, args)              => typeArgsInTopLevelType(pre) ++ args
+      case ExistentialType(tparams, underlying) => tparams.map(_.tpe) ++ typeArgsInTopLevelType(underlying)
+      case _                                    => Nil
+    }
+    tps filterNot isUnwarnableTypeArg
+  }
+
+  private class CheckabilityChecker(val X: Type, val P: Type) {
+    def Xsym = X.typeSymbol
+    def Psym = P.typeSymbol
+    def XR   = propagateKnownTypes(X, Psym)
+    // sadly the spec says (new java.lang.Boolean(true)).isInstanceOf[scala.Boolean]
+    def P1   = X matchesPattern P
+    def P2   = !Psym.isPrimitiveValueClass && isNeverSubType(X, P)
+    def P3   = isNonRefinementClassType(P) && (XR matchesPattern P)
+    def P4   = !(P1 || P2 || P3)
+
+    def summaryString = f"""
+      |Checking checkability of (x: $X) against pattern $P
+      |[P1] $P1%-6s X <: P             // $X  <: $P
+      |[P2] $P2%-6s x ∉ P              // (x ∈ $X) ⇒ (x ∉ $P)
+      |[P3] $P3%-6s XR <: P            // $XR <: $P
+      |[P4] $P4%-6s None of the above  // !(P1 || P2 || P3)
+    """.stripMargin.trim
+
+    val result = (
+      if (X.isErroneous || P.isErroneous) CheckabilityError
+      else if (P1) StaticallyTrue
+      else if (P2) StaticallyFalse
+      else if (P3) RuntimeCheckable
+      else if (uncheckableType == NoType) {
+        // Avoid warning (except ourselves) if we can't pinpoint the uncheckable type
+        debugwarn("Checkability checker says 'Uncheckable', but uncheckable type cannot be found:\n" + summaryString)
+        CheckabilityError
+      }
+      else Uncheckable
+    )
+    lazy val uncheckableType = if (Psym.isAbstractType) P else {
+      val possibles = typeArgsInTopLevelType(P).toSet
+      val opt = possibles find { targ =>
+        // Create a derived type with every possibly uncheckable type replaced
+        // with a WildcardType, except for 'targ'. If !(XR <: derived) then
+        // 'targ' is uncheckable.
+        val derived = P map (tp => if (possibles(tp) && !(tp =:= targ)) WildcardType else tp)
+        !(XR <:< derived)
+      }
+      opt getOrElse NoType
+    }
+
+    def neverSubClass = isNeverSubClass(Xsym, Psym)
+    def neverMatches  = result == StaticallyFalse
+    def isUncheckable = result == Uncheckable
+    def uncheckableMessage = uncheckableType match {
+      case NoType                                   => "something"
+      case tp @ RefinedType(_, _)                   => "refinement " + tp
+      case TypeRef(_, sym, _) if sym.isAbstractType => "abstract type " + sym.name
+      case tp                                       => "non-variable type argument " + tp
+    }
+  }
+
+  /** X, P, [P1], etc. are all explained at the top of the file.
+   */
+  private object CheckabilityChecker {
+    /** A knowable class is one which is either effectively final
+     *  itself, or sealed with only knowable children.
+     */
+    def isKnowable(sym: Symbol): Boolean = /*logResult(s"isKnowable($sym)")*/(
+         sym.initialize.isEffectivelyFinal  // pesky .initialize requirement, or we receive lies about isSealed
+      || sym.isSealed && (sym.children forall isKnowable)
+    )
+    def knownSubclasses(sym: Symbol): List[Symbol] = /*logResult(s"knownSubclasses($sym)")*/(sym :: {
+      if (sym.isSealed) sym.children.toList flatMap knownSubclasses
+      else Nil
+    })
+    def excludable(s1: Symbol, s2: Symbol) = /*logResult(s"excludable($s1, $s2)")*/(
+         isKnowable(s1)
+      && !(s2 isSubClass s1)
+      && knownSubclasses(s1).forall(child => !(child isSubClass s2))
+    )
+
+    /** Given classes A and B, can it be shown that nothing which is
+     *  an A will ever be a subclass of something which is a B? This
+     *  entails not only showing that !(A isSubClass B) but that the
+     *  same is true of all their subclasses.  Restated for symmetry:
+     *  the same value cannot be a member of both A and B.
+     *
+     *   1) A must not be a subclass of B, nor B of A (the trivial check)
+     *   2) One of A or B must be completely knowable (see isKnowable)
+     *   3) Assuming A is knowable, the proposition is true if
+     *      !(A' isSubClass B) for all A', where A' is a subclass of A.
+     *
+     *  Due to symmetry, the last condition applies as well in reverse.
+     */
+    def isNeverSubClass(sym1: Symbol, sym2: Symbol) = /*logResult(s"isNeverSubClass($sym1, $sym2)")*/(
+         sym1.isClass
+      && sym2.isClass
+      && (excludable(sym1, sym2) || excludable(sym2, sym1))
+    )
+    private def isNeverSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol]): Boolean = /*logResult(s"isNeverSubArgs($tps1, $tps2, $tparams)")*/ {
+      def isNeverSubArg(t1: Type, t2: Type, variance: Int) = {
+        if (variance > 0) isNeverSubType(t2, t1)
+        else if (variance < 0) isNeverSubType(t1, t2)
+        else isNeverSameType(t1, t2)
+      }
+      exists3(tps1, tps2, tparams map (_.variance))(isNeverSubArg)
+    }
+    private def isNeverSameType(tp1: Type, tp2: Type): Boolean = (tp1, tp2) match {
+      case (TypeRef(_, sym1, args1), TypeRef(_, sym2, args2)) =>
+        (    isNeverSubClass(sym1, sym2)
+          || isNeverSubClass(sym2, sym1)
+          || ((sym1 == sym2) && isNeverSubArgs(args1, args2, sym1.typeParams))
+        )
+      case _ =>
+        false
+    }
+    // Important to dealias at any entry point (this is the only one at this writing.)
+    def isNeverSubType(tp1: Type, tp2: Type): Boolean = /*logResult(s"isNeverSubType($tp1, $tp2)")*/((tp1.dealias, tp2.dealias) match {
+      case (TypeRef(_, sym1, args1), TypeRef(_, sym2, args2)) =>
+        isNeverSubClass(sym1, sym2) || {
+          (sym1 isSubClass sym2) && {
+            val tp1seen = tp1 baseType sym2
+            isNeverSubArgs(tp1seen.typeArgs, args2, sym2.typeParams)
+          }
+        }
+      case _ => false
+    })
+  }
+
+  trait InferCheckable {
+    self: Inferencer =>
+
+    /** TODO: much better error positions.
+     *  Kind of stuck right now because they just pass us the one tree.
+     *  TODO: Eliminate inPattern, canRemedy, which have no place here.
+     */
+    def checkCheckable(tree: Tree, P0: Type, X0: Type, inPattern: Boolean, canRemedy: Boolean = false) {
+      if (uncheckedOk(P0)) return
+      def where = if (inPattern) "pattern " else ""
+
+      // singleton types not considered here
+      val P = P0.widen
+      val X = X0.widen
+
+      P match {
+        // Prohibit top-level type tests for these, but they are ok nested (e.g. case Foldable[Nothing] => ... )
+        case TypeRef(_, NothingClass | NullClass | AnyValClass, _) =>
+          InferErrorGen.TypePatternOrIsInstanceTestError(tree, P)
+        // If top-level abstract types can be checked using a classtag extractor, don't warn about them
+        case TypeRef(_, sym, _) if sym.isAbstractType && canRemedy =>
+          ;
+        // Matching on types like case _: AnyRef { def bippy: Int } => doesn't work -- yet.
+        case RefinedType(_, decls) if !decls.isEmpty =>
+          getContext.unit.warning(tree.pos, s"a pattern match on a refinement type is unchecked")
+        case _ =>
+          val checker = new CheckabilityChecker(X, P)
+          log(checker.summaryString)
+          if (checker.neverMatches) {
+            val addendum = if (checker.neverSubClass) "" else " (but still might match its erasure)"
+            getContext.unit.warning(tree.pos, s"fruitless type test: a value of type $X cannot also be a $P$addendum")
+          }
+          else if (checker.isUncheckable) {
+            val msg = (
+              if (checker.uncheckableType =:= P) s"abstract type $where$P"
+              else s"${checker.uncheckableMessage} in type $where$P"
+            )
+            getContext.unit.warning(tree.pos, s"$msg is unchecked since it is eliminated by erasure")
+          }
+      }
+    }
+  }
+}
+
+private[typechecker] final class Checkability(val value: Int) extends AnyVal { }
+private[typechecker] object Checkability {
+  val StaticallyTrue    = new Checkability(0)
+  val StaticallyFalse   = new Checkability(1)
+  val RuntimeCheckable  = new Checkability(2)
+  val Uncheckable       = new Checkability(3)
+  val CheckabilityError = new Checkability(4)
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 22077303a4..0c3dcb9342 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -17,7 +17,7 @@ import scala.annotation.tailrec
  *  @author Martin Odersky
  *  @version 1.0
  */
-trait Infer {
+trait Infer extends Checkable {
   self: Analyzer =>
 
   import global._
@@ -254,7 +254,7 @@ trait Infer {
   private val stdErrorValue = stdErrorClass.newErrorValue(nme.ERROR)
 
   /** The context-dependent inferencer part */
-  class Inferencer(context: Context) extends InferencerContextErrors {
+  class Inferencer(context: Context) extends InferencerContextErrors with InferCheckable {
     import InferErrorGen._
 
     /* -- Error Messages --------------------------------------------------- */
@@ -1341,99 +1341,6 @@ trait Infer {
       check(tp, Nil)
     }
 
-    // if top-level abstract types can be checked using a classtag extractor, don't warn about them
-    def checkCheckable(tree: Tree, typeToTest: Type, typeEnsured: Type, inPattern: Boolean, canRemedy: Boolean = false) = {
-      log(s"checkCheckable($tree, $typeToTest, $typeEnsured, inPattern = $inPattern, canRemedy = $canRemedy")
-
-      sealed abstract class TypeConformance(check: (Type, Type) => Boolean) {
-        def apply(t1: Type, t2: Type): Boolean = check(t1, t2) && {
-          log(s"Skipping unchecked for statically verifiable condition $t1 ${this} $t2")
-          true
-        }
-      }
-      // I tried to use varianceInType to track the variance implications
-      // but I could not make it work.
-      case object =:= extends TypeConformance(_ =:= _)
-      case object <:< extends TypeConformance(_ <:< _)
-      case object >:> extends TypeConformance((t1, t2) => t2 <:< t1)
-      case object =!= extends TypeConformance((t1, t2) => false)
-
-      var bound: List[Symbol] = Nil
-      var warningMessages: List[String] = Nil
-
-      def isLocalBinding(sym: Symbol) = (
-        sym.isAbstractType && (
-             (bound contains sym)
-          || (sym.name == tpnme.WILDCARD)
-          || {
-            val e = context.scope.lookupEntry(sym.name)
-            (e ne null) && e.sym == sym && !e.sym.isTypeParameterOrSkolem && e.owner == context.scope
-          }
-        )
-      )
-      def check(tp0: Type, pt: Type, conformance: TypeConformance): Boolean = {
-        val tp = tp0.normalize
-        // Set the warning message to be issued when the top-level call fails.
-        def warn(what: String): Boolean = {
-          warningMessages ::= what
-          false
-        }
-        def checkArg(param: Symbol, arg: Type) = {
-          def conforms = (
-            if (param.isCovariant) <:<
-            else if (param.isContravariant) >:>
-            else =:=
-          )
-          (arg hasAnnotation UncheckedClass) || {
-            arg.withoutAnnotations match {
-              case TypeRef(_, sym, args) =>
-                (    isLocalBinding(sym)
-                  || arg.typeSymbol.isTypeParameterOrSkolem
-                  || (sym.name == tpnme.WILDCARD) // avoid spurious warnings on HK types
-                  || check(arg, param.tpeHK, conforms)
-                  || warn("non-variable type argument " + arg)
-                )
-              case _ =>
-                warn("non-variable type argument " + arg)
-            }
-          }
-        }
-
-        // Checking if pt (the expected type of the pattern, and the type
-        // we are guaranteed) conforms to tp (the type expressed in the pattern's
-        // type test.) If it does, then even if the type being checked for appears
-        // to be uncheckable, it is not a warning situation, because it is indeed
-        // checked: not at runtime, but statically.
-        conformance.apply(pt, tp) || (tp match {
-          case SingleType(pre, _)                           => check(pre, pt, =:=)
-          case ExistentialType(quantified, tp1)             => bound :::= quantified ; check(tp1, pt, <:<)
-          case ThisType(_) | NoPrefix                       => true
-          case RefinedType(parents, decls) if decls.isEmpty => parents forall (p => check(p, pt, <:<))
-          case RefinedType(_, _)                            => warn("refinement " + tp)
-          case TypeRef(_, ArrayClass, arg :: Nil)           => check(arg, NoType, =!=)
-          case TypeRef(_, NonLocalReturnControlClass, _)    => true // no way to suppress unchecked warnings on try/catch
-          // we only use the extractor for top-level type tests, type arguments remain unchecked
-          case TypeRef(_, sym, _) if sym.isAbstractType     => isLocalBinding(sym) || canRemedy || warn("abstract type " + tp)
-          case TypeRef(_, _, Nil)                           => false // leaf node
-          case TypeRef(pre, sym, args)                      => forall2(sym.typeParams, args)(checkArg) && check(pre, pt.prefix, =:=)
-          case _                                            => warn("type " + tp)
-        })
-      }
-      typeToTest match {
-        // Prohibit top-level type tests for these, but they are
-        // acceptable nested (e.g. case Foldable[Nothing] => ... )
-        case TypeRef(_, NothingClass | NullClass | AnyValClass, _) =>
-          TypePatternOrIsInstanceTestError(tree, typeToTest)
-        case _ =>
-          def where = ( if (inPattern) "pattern " else "" ) + typeToTest
-          if (check(typeToTest, typeEnsured, =:=)) ()
-          // Note that this is a regular warning, not an uncheckedWarning,
-          // which is now the province of such notifications as "pattern matcher
-          // exceeded its analysis budget."
-          else warningMessages foreach (m =>
-            context.unit.warning(tree.pos, s"$m in type $where is unchecked since it is eliminated by erasure"))
-      }
-    }
 
     /** Type intersection of simple type tp1 with general type tp2.
      *  The result eliminates some redundancies.
diff --git a/src/compiler/scala/tools/nsc/typechecker/Modes.scala b/src/compiler/scala/tools/nsc/typechecker/Modes.scala
index e9ea99faab..d942d080cb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Modes.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Modes.scala
@@ -86,6 +86,10 @@ trait Modes {
    */
   final val TYPEPATmode   = 0x10000
 
+  /** RETmode is set when we are typing a return expression.
+   */
+  final val RETmode       = 0x20000
+
   final private val StickyModes   = EXPRmode | PATTERNmode | TYPEmode | ALTmode
 
   final def onlyStickyModes(mode: Int) =
@@ -133,4 +137,4 @@ trait Modes {
   def modeString(mode: Int): String =
     if (mode == 0) "NOmode"
     else (modeNameMap filterKeys (bit => inAllModes(mode, bit))).values mkString " "
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index af89af74d0..c25b6c3726 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -253,12 +253,6 @@ trait Typers extends Modes with Adaptations with Tags {
         result
       }
     }
-    def isNonRefinementClassType(tpe: Type) = tpe match {
-      case SingleType(_, sym) => sym.isModuleClass
-      case TypeRef(_, sym, _) => sym.isClass && !sym.isRefinementClass
-      case ErrorType          => true
-      case _                  => false
-    }
     private def errorNotClass(tpt: Tree, found: Type)  = { ClassTypeRequiredError(tpt, found); false }
     private def errorNotStable(tpt: Tree, found: Type) = { TypeNotAStablePrefixError(tpt, found); false }
 
@@ -3768,9 +3762,13 @@ trait Typers extends Modes with Adaptations with Tags {
           if (fun.symbol == Predef_classOf)
             typedClassOf(tree, args.head, true)
           else {
-            if (!isPastTyper && fun.symbol == Any_isInstanceOf && !targs.isEmpty)
-              checkCheckable(tree, targs.head, AnyClass.tpe, inPattern = false)
-
+            if (!isPastTyper && fun.symbol == Any_isInstanceOf && targs.nonEmpty) {
+              val scrutineeType = fun match {
+                case Select(qual, _) => qual.tpe
+                case _               => AnyClass.tpe
+              }
+              checkCheckable(tree, targs.head, scrutineeType, inPattern = false)
+            }
             val resultpe = restpe.instantiateTypeParams(tparams, targs)
             //@M substitution in instantiateParams needs to be careful!
             //@M example: class Foo[a] { def foo[m[x]]: m[a] = error("") } (new Foo[Int]).foo[List] : List[Int]
@@ -3780,7 +3778,8 @@ trait Typers extends Modes with Adaptations with Tags {
             //println("instantiating type params "+restpe+" "+tparams+" "+targs+" = "+resultpe)
             treeCopy.TypeApply(tree, fun, args) setType resultpe
           }
-        } else {
+        }
+        else {
           TypedApplyWrongNumberOfTpeParametersError(tree, fun)
         }
       case ErrorType =>
@@ -4177,7 +4176,7 @@ trait Typers extends Modes with Adaptations with Tags {
             ReturnWithoutTypeError(tree, enclMethod.owner)
           } else {
             context.enclMethod.returnsSeen = true
-            val expr1: Tree = typed(expr, EXPRmode | BYVALmode, restpt.tpe)
+            val expr1: Tree = typed(expr, EXPRmode | BYVALmode | RETmode, restpt.tpe)
             // Warn about returning a value if no value can be returned.
             if (restpt.tpe.typeSymbol == UnitClass) {
               // The typing in expr1 says expr is Unit (it has already been coerced if
@@ -4186,7 +4185,8 @@ trait Typers extends Modes with Adaptations with Tags {
               if (typed(expr).tpe.typeSymbol != UnitClass)
                 unit.warning(tree.pos, "enclosing method " + name + " has result type Unit: return value discarded")
             }
-            treeCopy.Return(tree, checkDead(expr1)) setSymbol enclMethod.owner setType NothingClass.tpe
+            treeCopy.Return(tree, checkDead(expr1)).setSymbol(enclMethod.owner)
+                                                   .setType(adaptTypeOfReturn(expr1, restpt.tpe, NothingClass.tpe))
           }
         }
       }
diff --git a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
index a20ff1667b..b373b3d0de 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
@@ -150,10 +150,8 @@ abstract class CPSAnnotationChecker extends CPSUtils with Modes {
       if ((mode & global.analyzer.EXPRmode) != 0) {
         if ((annots1 corresponds annots2)(_.atp <:< _.atp)) {
           vprintln("already same, can't adapt further")
-          return false
-        }
-
-        if (annots1.isEmpty && !annots2.isEmpty && ((mode & global.analyzer.BYVALmode) == 0)) {
+          false
+        } else if (annots1.isEmpty && !annots2.isEmpty && ((mode & global.analyzer.BYVALmode) == 0)) {
           //println("can adapt annotations? " + tree + " / " + tree.tpe + " / " + Integer.toHexString(mode) + " / " + pt)
           if (!hasPlusMarker(tree.tpe)) {
   //          val base = tree.tpe <:< removeAllCPSAnnotations(pt)
@@ -163,17 +161,26 @@ abstract class CPSAnnotationChecker extends CPSUtils with Modes {
             // TBD: use same or not?
             //if (same) {
               vprintln("yes we can!! (unit)")
-              return true
+              true
             //}
-          }
-        } else if (!annots1.isEmpty && ((mode & global.analyzer.BYVALmode) != 0)) {
-          if (!hasMinusMarker(tree.tpe)) {
+          } else false
+        } else if (!hasPlusMarker(tree.tpe) && annots1.isEmpty && !annots2.isEmpty && ((mode & global.analyzer.RETmode) != 0)) {
+          vprintln("checking enclosing method's result type without annotations")
+          tree.tpe <:< pt.withoutAnnotations
+        } else if (!hasMinusMarker(tree.tpe) && !annots1.isEmpty && ((mode & global.analyzer.BYVALmode) != 0)) {
+          val optCpsTypes: Option[(Type, Type)]         = cpsParamTypes(tree.tpe)
+          val optExpectedCpsTypes: Option[(Type, Type)] = cpsParamTypes(pt)
+          if (optCpsTypes.isEmpty || optExpectedCpsTypes.isEmpty) {
             vprintln("yes we can!! (byval)")
-            return true
+            true
+          } else { // check cps param types
+            val cpsTpes = optCpsTypes.get
+            val cpsPts  = optExpectedCpsTypes.get
+            // class cpsParam[-B,+C], therefore:
+            cpsPts._1 <:< cpsTpes._1 && cpsTpes._2 <:< cpsPts._2
           }
-        }
-      }
-      false
+        } else false
+      } else false
     }
 
     override def adaptAnnotations(tree: Tree, mode: Int, pt: Type): Tree = {
@@ -184,6 +191,7 @@ abstract class CPSAnnotationChecker extends CPSUtils with Modes {
       val patMode   = (mode & global.analyzer.PATTERNmode) != 0
       val exprMode  = (mode & global.analyzer.EXPRmode) != 0
       val byValMode = (mode & global.analyzer.BYVALmode) != 0
+      val retMode   = (mode & global.analyzer.RETmode) != 0
 
       val annotsTree     = cpsParamAnnotation(tree.tpe)
       val annotsExpected = cpsParamAnnotation(pt)
@@ -210,9 +218,38 @@ abstract class CPSAnnotationChecker extends CPSUtils with Modes {
         val res = tree modifyType addMinusMarker
         vprintln("adapted annotations (by val) of " + tree + " to " + res.tpe)
         res
+      } else if (retMode && !hasPlusMarker(tree.tpe) && annotsTree.isEmpty && annotsExpected.nonEmpty) {
+        // add a marker annotation that will make tree.tpe behave as pt, subtyping wise
+        // tree will look like having any possible annotation
+        
+        // note 1: we are only adding a plus marker if the method's result type is a cps type
+        //         (annotsExpected.nonEmpty == cpsParamAnnotation(pt).nonEmpty)
+        // note 2: we are not adding the expected cps annotations, since they will be added
+        //         by adaptTypeOfReturn (see below).
+        val res = tree modifyType (_ withAnnotations List(newPlusMarker()))
+        vprintln("adapted annotations (return) of " + tree + " to " + res.tpe)
+        res
       } else tree
     }
 
+    /** Returns an adapted type for a return expression if the method's result type (pt) is a CPS type.
+     *  Otherwise, it returns the `default` type (`typedReturn` passes `NothingClass.tpe`).
+     *  
+     *  A return expression in a method that has a CPS result type is an error unless the return
+     *  is in tail position. Therefore, we are making sure that only the types of return expressions
+     *  are adapted which will either be removed, or lead to an error.
+     */
+    override def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type = {
+      // only adapt if method's result type (pt) is cps type
+      val annots = cpsParamAnnotation(pt)
+      if (annots.nonEmpty) {
+        // return type of `tree` without plus marker, but only if it doesn't have other cps annots
+        if (hasPlusMarker(tree.tpe) && !hasCpsParamTypes(tree.tpe))
+          tree.setType(removeAttribs(tree.tpe, MarkerCPSAdaptPlus))
+        tree.tpe
+      } else default
+    }
+
     def updateAttributesFromChildren(tpe: Type, childAnnots: List[AnnotationInfo], byName: List[Tree]): Type = {
       tpe match {
         // Would need to push annots into each alternative of overloaded type
diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
index 51760d2807..ba87cadfeb 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
@@ -32,6 +32,55 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
     implicit val _unit = unit // allow code in CPSUtils.scala to report errors
     var cpsAllowed: Boolean = false // detect cps code in places we do not handle (yet)
 
+    object RemoveTailReturnsTransformer extends Transformer {
+      override def transform(tree: Tree): Tree = tree match {
+        case Block(stms, r @ Return(expr)) =>
+          treeCopy.Block(tree, stms, expr)
+
+        case Block(stms, expr) =>
+          treeCopy.Block(tree, stms, transform(expr))
+
+        case If(cond, r1 @ Return(thenExpr), r2 @ Return(elseExpr)) =>
+          treeCopy.If(tree, cond, transform(thenExpr), transform(elseExpr))
+
+        case If(cond, r1 @ Return(thenExpr), elseExpr) =>
+          treeCopy.If(tree, cond, transform(thenExpr), transform(elseExpr))
+
+        case If(cond, thenExpr, r2 @ Return(elseExpr)) =>
+          treeCopy.If(tree, cond, transform(thenExpr), transform(elseExpr))
+
+        case If(cond, thenExpr, elseExpr) =>
+          treeCopy.If(tree, cond, transform(thenExpr), transform(elseExpr))
+
+        case Try(block, catches, finalizer) =>
+          treeCopy.Try(tree,
+                       transform(block),
+                       (catches map (t => transform(t))).asInstanceOf[List[CaseDef]],
+                       transform(finalizer))
+
+        case CaseDef(pat, guard, r @ Return(expr)) =>
+          treeCopy.CaseDef(tree, pat, guard, expr)
+
+        case CaseDef(pat, guard, body) =>
+          treeCopy.CaseDef(tree, pat, guard, transform(body))
+
+        case Return(_) =>
+          unit.error(tree.pos, "return expressions in CPS code must be in tail position")
+          tree
+
+        case _ =>
+          super.transform(tree)
+      }
+    }
+
+    def removeTailReturns(body: Tree): Tree = {
+      // support body with single return expression
+      body match {
+        case Return(expr) => expr
+        case _ => RemoveTailReturnsTransformer.transform(body)
+      }
+    }
+
     override def transform(tree: Tree): Tree = {
       if (!cpsEnabled) return tree
 
@@ -46,11 +95,14 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
         // this would cause infinite recursion. But we could remove the
         // ValDef case here.
 
-        case dd @ DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
+        case dd @ DefDef(mods, name, tparams, vparamss, tpt, rhs0) =>
           debuglog("transforming " + dd.symbol)
 
           atOwner(dd.symbol) {
-            val rhs1 = transExpr(rhs, None, getExternalAnswerTypeAnn(tpt.tpe))
+            val rhs =
+              if (cpsParamTypes(tpt.tpe).nonEmpty) removeTailReturns(rhs0)
+              else rhs0
+            val rhs1 = transExpr(rhs, None, getExternalAnswerTypeAnn(tpt.tpe))(getExternalAnswerTypeAnn(tpt.tpe).isDefined)
 
             debuglog("result "+rhs1)
             debuglog("result is of type "+rhs1.tpe)
@@ -75,6 +127,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
 
             val ext = getExternalAnswerTypeAnn(body.tpe)
             val pureBody = getAnswerTypeAnn(body.tpe).isEmpty
+            implicit val isParentImpure = ext.isDefined
 
             def transformPureMatch(tree: Tree, selector: Tree, cases: List[CaseDef]) = {
               val caseVals = cases map { case cd @ CaseDef(pat, guard, body) =>
@@ -154,8 +207,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
     }
 
 
-    def transExpr(tree: Tree, cpsA: CPSInfo, cpsR: CPSInfo): Tree = {
-      transTailValue(tree, cpsA, cpsR) match {
+    def transExpr(tree: Tree, cpsA: CPSInfo, cpsR: CPSInfo)(implicit isAnyParentImpure: Boolean = false): Tree = {
+      transTailValue(tree, cpsA, cpsR)(cpsR.isDefined || isAnyParentImpure) match {
         case (Nil, b) => b
         case (a, b) =>
           treeCopy.Block(tree, a,b)
@@ -163,7 +216,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
     }
 
 
-    def transArgList(fun: Tree, args: List[Tree], cpsA: CPSInfo): (List[List[Tree]], List[Tree], CPSInfo) = {
+    def transArgList(fun: Tree, args: List[Tree], cpsA: CPSInfo)(implicit isAnyParentImpure: Boolean): (List[List[Tree]], List[Tree], CPSInfo) = {
       val formals = fun.tpe.paramTypes
       val overshoot = args.length - formals.length
 
@@ -172,7 +225,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
       val (stm,expr) = (for ((a,tp) <- args.zip(formals ::: List.fill(overshoot)(NoType))) yield {
         tp match {
           case TypeRef(_, ByNameParamClass, List(elemtp)) =>
-            (Nil, transExpr(a, None, getAnswerTypeAnn(elemtp)))
+            // note that we're not passing just isAnyParentImpure
+            (Nil, transExpr(a, None, getAnswerTypeAnn(elemtp))(getAnswerTypeAnn(elemtp).isDefined || isAnyParentImpure))
           case _ =>
             val (valStm, valExpr, valSpc) = transInlineValue(a, spc)
             spc = valSpc
@@ -184,7 +238,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
     }
 
 
-    def transValue(tree: Tree, cpsA: CPSInfo, cpsR: CPSInfo): (List[Tree], Tree, CPSInfo) = {
+    // precondition: cpsR.isDefined "implies" isAnyParentImpure
+    def transValue(tree: Tree, cpsA: CPSInfo, cpsR: CPSInfo)(implicit isAnyParentImpure: Boolean): (List[Tree], Tree, CPSInfo) = {
       // return value: (stms, expr, spc), where spc is CPSInfo after stms but *before* expr
       implicit val pos = tree.pos
       tree match {
@@ -192,7 +247,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
           val (cpsA2, cpsR2) = (cpsA, linearize(cpsA, getAnswerTypeAnn(tree.tpe))) // tbd
           //          val (cpsA2, cpsR2) = (None, getAnswerTypeAnn(tree.tpe))
 
-          val (a, b) = transBlock(stms, expr, cpsA2, cpsR2)
+          val (a, b) = transBlock(stms, expr, cpsA2, cpsR2)(cpsR2.isDefined || isAnyParentImpure)
           val tree1  = (treeCopy.Block(tree, a, b)) // no updateSynthFlag here!!!
 
           (Nil, tree1, cpsA)
@@ -206,8 +261,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
           val (cpsA2, cpsR2) = if (hasSynthMarker(tree.tpe))
             (spc, linearize(spc, getAnswerTypeAnn(tree.tpe))) else
             (None, getAnswerTypeAnn(tree.tpe)) // if no cps in condition, branches must conform to tree.tpe directly
-          val thenVal = transExpr(thenp, cpsA2, cpsR2)
-          val elseVal = transExpr(elsep, cpsA2, cpsR2)
+          val thenVal = transExpr(thenp, cpsA2, cpsR2)(cpsR2.isDefined || isAnyParentImpure)
+          val elseVal = transExpr(elsep, cpsA2, cpsR2)(cpsR2.isDefined || isAnyParentImpure)
 
           // check that then and else parts agree (not necessary any more, but left as sanity check)
           if (cpsR.isDefined) {
@@ -227,7 +282,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
             else (None, getAnswerTypeAnn(tree.tpe))
 
           val caseVals = cases map { case cd @ CaseDef(pat, guard, body) =>
-            val bodyVal = transExpr(body, cpsA2, cpsR2)
+            val bodyVal = transExpr(body, cpsA2, cpsR2)(cpsR2.isDefined || isAnyParentImpure)
             treeCopy.CaseDef(cd, transform(pat), transform(guard), bodyVal)
           }
 
@@ -245,7 +300,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
             // currentOwner.newMethod(name, tree.pos, Flags.SYNTHETIC) setInfo ldef.symbol.info
             val sym    = ldef.symbol resetFlag Flags.LABEL
             val rhs1   = rhs //new TreeSymSubstituter(List(ldef.symbol), List(sym)).transform(rhs)
-            val rhsVal = transExpr(rhs1, None, getAnswerTypeAnn(tree.tpe)) changeOwner (currentOwner -> sym)
+            val rhsVal = transExpr(rhs1, None, getAnswerTypeAnn(tree.tpe))(getAnswerTypeAnn(tree.tpe).isDefined || isAnyParentImpure) changeOwner (currentOwner -> sym)
 
             val stm1 = localTyper.typed(DefDef(sym, rhsVal))
             // since virtpatmat does not rely on fall-through, don't call the labels it emits
@@ -284,6 +339,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
           (stms, updateSynthFlag(treeCopy.Assign(tree, transform(lhs), expr)), spc)
 
         case Return(expr0) =>
+          if (isAnyParentImpure)
+            unit.error(tree.pos, "return expression not allowed, since method calls CPS method")
           val (stms, expr, spc) = transInlineValue(expr0, cpsA)
           (stms, updateSynthFlag(treeCopy.Return(tree, expr)), spc)
 
@@ -321,7 +378,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
       }
     }
 
-    def transTailValue(tree: Tree, cpsA: CPSInfo, cpsR: CPSInfo): (List[Tree], Tree) = {
+    // precondition: cpsR.isDefined "implies" isAnyParentImpure
+    def transTailValue(tree: Tree, cpsA: CPSInfo, cpsR: CPSInfo)(implicit isAnyParentImpure: Boolean): (List[Tree], Tree) = {
 
       val (stms, expr, spc) = transValue(tree, cpsA, cpsR)
 
@@ -398,7 +456,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
       (stms, expr)
     }
 
-    def transInlineValue(tree: Tree, cpsA: CPSInfo): (List[Tree], Tree, CPSInfo) = {
+    def transInlineValue(tree: Tree, cpsA: CPSInfo)(implicit isAnyParentImpure: Boolean): (List[Tree], Tree, CPSInfo) = {
 
       val (stms, expr, spc) = transValue(tree, cpsA, None) // never required to be cps
 
@@ -425,7 +483,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
 
 
 
-    def transInlineStm(stm: Tree, cpsA: CPSInfo):  (List[Tree], CPSInfo) = {
+    def transInlineStm(stm: Tree, cpsA: CPSInfo)(implicit isAnyParentImpure: Boolean):  (List[Tree], CPSInfo) = {
       stm match {
 
         // TODO: what about DefDefs?
@@ -455,7 +513,8 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
       }
     }
 
-    def transBlock(stms: List[Tree], expr: Tree, cpsA: CPSInfo, cpsR: CPSInfo): (List[Tree], Tree) = {
+    // precondition: cpsR.isDefined "implies" isAnyParentImpure
+    def transBlock(stms: List[Tree], expr: Tree, cpsA: CPSInfo, cpsR: CPSInfo)(implicit isAnyParentImpure: Boolean): (List[Tree], Tree) = {
       def rec(currStats: List[Tree], currAns: CPSInfo, accum: List[Tree]): (List[Tree], Tree) =
         currStats match {
           case Nil =>
diff --git a/src/library/scala/throws.scala b/src/library/scala/throws.scala
index 0aa0d31c9f..02dffb00b0 100644
--- a/src/library/scala/throws.scala
+++ b/src/library/scala/throws.scala
@@ -14,7 +14,7 @@ package scala
  * {{{
  * class Reader(fname: String) {
  *   private val in = new BufferedReader(new FileReader(fname))
- *   @throws(classOf[IOException])
+ *   @throws[IOException]("if the file doesn't exist")
  *   def read() = in.read()
  * }
  * }}}
@@ -23,4 +23,6 @@ package scala
  * @version 1.0, 19/05/2006
  * @since   2.1
  */
-class throws(clazz: Class[_]) extends scala.annotation.StaticAnnotation
+class throws[T <: Throwable](cause: String = "") extends scala.annotation.StaticAnnotation {
+  def this(clazz: Class[T]) = this()
+}
diff --git a/src/reflect/scala/reflect/internal/AnnotationCheckers.scala b/src/reflect/scala/reflect/internal/AnnotationCheckers.scala
index 9f102c5712..05f80c8a0c 100644
--- a/src/reflect/scala/reflect/internal/AnnotationCheckers.scala
+++ b/src/reflect/scala/reflect/internal/AnnotationCheckers.scala
@@ -47,6 +47,13 @@ trait AnnotationCheckers {
      *  before. If the implementing class cannot do the adaptiong, it
      *  should return the tree unchanged.*/
     def adaptAnnotations(tree: Tree, mode: Int, pt: Type): Tree = tree
+
+    /** Adapt the type of a return expression. The decision of an annotation checker
+     *  whether the type should be adapted is based on the type of the expression
+     *  which is returned, as well as the result type of the method (pt).
+     *  By default, this method simply returns the passed `default` type.
+     */
+    def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type = default
   }
 
   // Syncnote: Annotation checkers inaccessible to reflection, so no sync in var necessary.
@@ -118,4 +125,23 @@ trait AnnotationCheckers {
     annotationCheckers.foldLeft(tree)((tree, checker) =>
       checker.adaptAnnotations(tree, mode, pt))
   }
+
+  /** Let a registered annotation checker adapt the type of a return expression.
+   *  Annotation checkers that cannot do the adaptation should simply return
+   *  the `default` argument.
+   *  
+   *  Note that the result is undefined if more than one annotation checker
+   *  returns an adapted type which is not a subtype of `default`.
+   */
+  def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type = {
+    val adaptedTypes = annotationCheckers flatMap { checker =>
+      val adapted = checker.adaptTypeOfReturn(tree, pt, default)
+      if (!(adapted <:< default)) List(adapted)
+      else List()
+    }
+    adaptedTypes match {
+      case fst :: _ => fst
+      case List() => default
+    }
+  }
 }
diff --git a/src/reflect/scala/reflect/internal/AnnotationInfos.scala b/src/reflect/scala/reflect/internal/AnnotationInfos.scala
index 3bd7f4f4fa..46e4329b2e 100644
--- a/src/reflect/scala/reflect/internal/AnnotationInfos.scala
+++ b/src/reflect/scala/reflect/internal/AnnotationInfos.scala
@@ -30,7 +30,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
     /** Symbols of any @throws annotations on this symbol.
      */
     def throwsAnnotations(): List[Symbol] = annotations collect {
-      case AnnotationInfo(tp, Literal(Constant(tpe: Type)) :: Nil, _) if tp.typeSymbol == ThrowsClass => tpe.typeSymbol
+      case ThrownException(exc) => exc
     }
 
     /** Tests for, get, or remove an annotation */
@@ -325,4 +325,23 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
   implicit val AnnotationTag = ClassTag[AnnotationInfo](classOf[AnnotationInfo])
 
   object UnmappableAnnotation extends CompleteAnnotationInfo(NoType, Nil, Nil)
+  
+  /** Extracts symbol of thrown exception from AnnotationInfo.
+    * 
+    * Supports both “old-style” `@throws(classOf[Exception])`
+    * as well as “new-stye” `@throws[Exception]("cause")` annotations.
+    */
+  object ThrownException {
+    def unapply(ann: AnnotationInfo): Option[Symbol] = 
+      ann match {
+        case AnnotationInfo(tpe, _, _) if tpe.typeSymbol != ThrowsClass =>
+          None
+        // old-style: @throws(classOf[Exception]) (which is throws[T](classOf[Exception]))
+        case AnnotationInfo(_, List(Literal(Constant(tpe: Type))), _) =>
+          Some(tpe.typeSymbol)
+        // new-style: @throws[Exception], @throws[Exception]("cause")
+        case AnnotationInfo(TypeRef(_, _, args), _, _) =>
+          Some(args.head.typeSymbol)
+      }
+  }
 }
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 6cdca3d7f8..2bc9f02758 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -954,7 +954,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ScalaNoInlineClass         = requiredClass[scala.noinline]
     lazy val SerialVersionUIDAttr       = requiredClass[scala.SerialVersionUID]
     lazy val SpecializedClass           = requiredClass[scala.specialized]
-    lazy val ThrowsClass                = requiredClass[scala.throws]
+    lazy val ThrowsClass                = requiredClass[scala.throws[_]]
     lazy val TransientAttr              = requiredClass[scala.transient]
     lazy val UncheckedClass             = requiredClass[scala.unchecked]
     lazy val UnspecializedClass         = requiredClass[scala.annotation.unspecialized]
diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index cb8dc4b197..fb165ab50f 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -576,7 +576,8 @@ trait Printers extends api.Printers { self: SymbolTable =>
               case _ => // do nothing
             })
         case sym: Symbol =>
-          if (sym.isStatic && (sym.isClass || sym.isModule)) print(sym.fullName)
+          if (sym == NoSymbol) print("NoSymbol")
+          else if (sym.isStatic && (sym.isClass || sym.isModule)) print(sym.fullName)
           else print(sym.name)
           if (printIds) print("#", sym.id)
           if (printKinds) print("#", sym.abbreviatedKindString)
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 2cdfb05e77..eacbf6a0cc 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -346,6 +346,16 @@ trait StdNames {
     def isSingletonName(name: Name)         = name endsWith SINGLETON_SUFFIX
     def isModuleName(name: Name)            = name endsWith MODULE_SUFFIX_NAME
 
+    /** Is name a variable name? */
+    def isVariableName(name: Name): Boolean = {
+      val first = name.startChar
+      (    ((first.isLower && first.isLetter) || first == '_')
+        && (name != nme.false_)
+        && (name != nme.true_)
+        && (name != nme.null_)
+      )
+    }
+
     def isDeprecatedIdentifierName(name: Name) = name.toTermName match {
       case nme.`then` | nme.`macro` => true
       case _                        => false
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 21506a498d..b132b91946 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -91,8 +91,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def module                            = sourceModule
     def thisPrefix: Type                  = thisType
     def selfType: Type                    = typeOfThis
-    def typeSignature: Type               = info
-    def typeSignatureIn(site: Type): Type = site memberInfo this
+    def typeSignature: Type               = { fullyInitializeSymbol(this); info }
+    def typeSignatureIn(site: Type): Type = { fullyInitializeSymbol(this); site memberInfo this }
 
     def toType: Type = tpe
     def toTypeIn(site: Type): Type = site.memberType(this)
@@ -2999,7 +2999,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     }
 
     override def derivedValueClassUnbox =
-      (info.decl(nme.unbox)) orElse
+      // (info.decl(nme.unbox)) orElse      uncomment once we accept unbox methods
       (info.decls.find(_ hasAllFlags PARAMACCESSOR | METHOD) getOrElse
        NoSymbol)
 
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 6ef4c3f660..68decc27f5 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -247,7 +247,7 @@ abstract class TreeInfo {
 
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = pat match {
-    case x: Ident           => !x.isBackquoted && isVariableName(x.name)
+    case x: Ident           => !x.isBackquoted && nme.isVariableName(x.name)
     case _                  => false
   }
   def isDeprecatedIdentifier(tree: Tree): Boolean = tree match {
@@ -312,14 +312,6 @@ abstract class TreeInfo {
   /** Is name a left-associative operator? */
   def isLeftAssoc(operator: Name) = operator.nonEmpty && (operator.endChar != ':')
 
-  private val reserved = Set[Name](nme.false_, nme.true_, nme.null_)
-
-  /** Is name a variable name? */
-  def isVariableName(name: Name): Boolean = {
-    val first = name.startChar
-    ((first.isLower && first.isLetter) || first == '_') && !reserved(name)
-  }
-
   /** Is tree a `this` node which belongs to `enclClass`? */
   def isSelf(tree: Tree, enclClass: Symbol): Boolean = tree match {
     case This(_) => tree.symbol == enclClass
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index fd5694b599..0e8665ee84 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -66,9 +66,9 @@ import util.ThreeValues._
     // a type variable
     // Replace occurrences of type parameters with type vars, where
     // inst is the instantiation and constr is a list of bounds.
-  case DeBruijnIndex(level, index)
+  case DeBruijnIndex(level, index, args)
     // for dependent method types: a type referring to a method parameter.
-  case ErasedValueType(clazz, underlying)
+  case ErasedValueType(tref)
     // only used during erasure of derived value classes.
 */
 
@@ -3623,9 +3623,20 @@ trait Types extends api.Types { self: SymbolTable =>
 */
 
   /** A creator for type applications */
-  def appliedType(tycon: Type, args: List[Type]): Type =
-    if (args.isEmpty) tycon //@M! `if (args.isEmpty) tycon' is crucial (otherwise we create new types in phases after typer and then they don't get adapted (??))
-    else tycon match {
+  def appliedType(tycon: Type, args: List[Type]): Type = {
+    if (args.isEmpty)
+      return tycon //@M! `if (args.isEmpty) tycon' is crucial (otherwise we create new types in phases after typer and then they don't get adapted (??))
+
+    /** Disabled - causes cycles in tcpoly tests. */
+    if (false && isDefinitionsInitialized) {
+      assert(isUseableAsTypeArgs(args), {
+        val tapp_s = s"""$tycon[${args mkString ", "}]"""
+        val arg_s  = args filterNot isUseableAsTypeArg map (t => t + "/" + t.getClass) mkString ", "
+        s"$tapp_s includes illegal type argument $arg_s"
+      })
+    }
+
+    tycon match {
       case TypeRef(pre, sym @ (NothingClass|AnyClass), _) => copyTypeRef(tycon, pre, sym, Nil)   //@M drop type args to Any/Nothing
       case TypeRef(pre, sym, _)                           => copyTypeRef(tycon, pre, sym, args)
       case PolyType(tparams, restpe)                      => restpe.instantiateTypeParams(tparams, args)
@@ -3639,6 +3650,7 @@ trait Types extends api.Types { self: SymbolTable =>
       case WildcardType                                   => tycon // needed for neg/t0226
       case _                                              => abort(debugString(tycon))
     }
+  }
 
   /** Very convenient. */
   def appliedType(tyconSym: Symbol, args: Type*): Type =
@@ -5732,6 +5744,107 @@ trait Types extends api.Types { self: SymbolTable =>
     case _ => false
   }
 
+  /** This is defined and named as it is because the goal is to exclude source
+   *  level types which are not value types (e.g. MethodType) without excluding
+   *  necessary internal types such as WildcardType.  There are also non-value
+   *  types which can be used as type arguments (e.g. type constructors.)
+   */
+  def isUseableAsTypeArg(tp: Type) = (
+       isInternalTypeUsedAsTypeArg(tp)  // the subset of internal types which can be type args
+    || isHKTypeRef(tp)                  // not a value type, but ok as a type arg
+    || isValueElseNonValue(tp)          // otherwise only value types
+  )
+
+  private def isHKTypeRef(tp: Type) = tp match {
+    case TypeRef(_, sym, Nil) => tp.isHigherKinded
+    case _                    => false
+  }
+  @tailrec final def isUseableAsTypeArgs(tps: List[Type]): Boolean = tps match {
+    case Nil     => true
+    case x :: xs => isUseableAsTypeArg(x) && isUseableAsTypeArgs(xs)
+  }
+
+  /** The "third way", types which are neither value types nor
+   *  non-value types as defined in the SLS, further divided into
+   *  types which are used internally in type applications and
+   *  types which are not.
+   */
+  private def isInternalTypeNotUsedAsTypeArg(tp: Type): Boolean = tp match {
+    case AntiPolyType(pre, targs)            => true
+    case ClassInfoType(parents, defs, clazz) => true
+    case DeBruijnIndex(level, index, args)   => true
+    case ErasedValueType(tref)               => true
+    case NoPrefix                            => true
+    case NoType                              => true
+    case SuperType(thistpe, supertpe)        => true
+    case TypeBounds(lo, hi)                  => true
+    case _                                   => false
+  }
+  private def isInternalTypeUsedAsTypeArg(tp: Type): Boolean = tp match {
+    case WildcardType           => true
+    case BoundedWildcardType(_) => true
+    case ErrorType              => true
+    case _: TypeVar             => true
+    case _                      => false
+  }
+  private def isAlwaysValueType(tp: Type) = tp match {
+    case RefinedType(_, _)       => true
+    case ExistentialType(_, _)   => true
+    case ConstantType(_)         => true
+    case _                       => false
+  }
+  private def isAlwaysNonValueType(tp: Type) = tp match {
+    case OverloadedType(_, _)          => true
+    case NullaryMethodType(_)          => true
+    case MethodType(_, _)              => true
+    case PolyType(_, MethodType(_, _)) => true
+    case _                             => false
+  }
+  /** Should be called only with types for which a clear true/false answer
+   *  can be given: true == value type, false == non-value type.  Otherwise,
+   *  an exception is thrown.
+   */
+  private def isValueElseNonValue(tp: Type): Boolean = tp match {
+    case tp if isAlwaysValueType(tp)           => true
+    case tp if isAlwaysNonValueType(tp)        => false
+    case AnnotatedType(_, underlying, _)       => isValueElseNonValue(underlying)
+    case SingleType(_, sym)                    => sym.isValue           // excludes packages and statics
+    case TypeRef(_, _, _) if tp.isHigherKinded => false                 // excludes type constructors
+    case ThisType(sym)                         => !sym.isPackageClass   // excludes packages
+    case TypeRef(_, sym, _)                    => !sym.isPackageClass   // excludes packages
+    case PolyType(_, _)                        => true                  // poly-methods excluded earlier
+    case tp                                    => sys.error("isValueElseNonValue called with third-way type " + tp)
+  }
+
+  /** SLS 3.2, Value Types
+   *  Is the given type definitely a value type? A true result means
+   *  it verifiably is, but a false result does not mean it is not,
+   *  only that it cannot be assured.  To avoid false positives, this
+   *  defaults to false, but since Type is not sealed, one should take
+   *  a false answer with a grain of salt.  This method may be primarily
+   *  useful as documentation; it is likely that !isNonValueType(tp)
+   *  will serve better than isValueType(tp).
+   */
+  def isValueType(tp: Type) = isValueElseNonValue(tp)
+
+  /** SLS 3.3, Non-Value Types
+   *  Is the given type definitely a non-value type, as defined in SLS 3.3?
+   *  The specification-enumerated non-value types are method types, polymorphic
+   *  method types, and type constructors.  Supplements to the specified set of
+   *  non-value types include: types which wrap non-value symbols (packages
+   *  abd statics), overloaded types. Varargs and by-name types T* and (=>T) are
+   *  not designated non-value types because there is code which depends on using
+   *  them as type arguments, but their precise status is unclear.
+   */
+  def isNonValueType(tp: Type) = !isValueElseNonValue(tp)
+
+  def isNonRefinementClassType(tpe: Type) = tpe match {
+    case SingleType(_, sym) => sym.isModuleClass
+    case TypeRef(_, sym, _) => sym.isClass && !sym.isRefinementClass
+    case ErrorType          => true
+    case _                  => false
+  }
+
   // @assume tp1.isHigherKinded || tp2.isHigherKinded
   def isHKSubType0(tp1: Type, tp2: Type, depth: Int): Boolean = (
     tp1.typeSymbol == NothingClass
diff --git a/src/reflect/scala/reflect/internal/util/Collections.scala b/src/reflect/scala/reflect/internal/util/Collections.scala
index 14b5d3003d..201b4dfe0a 100644
--- a/src/reflect/scala/reflect/internal/util/Collections.scala
+++ b/src/reflect/scala/reflect/internal/util/Collections.scala
@@ -175,6 +175,20 @@ trait Collections {
     }
     false
   }
+  final def exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean = {
+    var ys1 = xs1
+    var ys2 = xs2
+    var ys3 = xs3
+    while (!ys1.isEmpty && !ys2.isEmpty && !ys3.isEmpty) {
+      if (f(ys1.head, ys2.head, ys3.head))
+        return true
+
+      ys1 = ys1.tail
+      ys2 = ys2.tail
+      ys3 = ys3.tail
+    }
+    false
+  }
   final def forall2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) => Boolean): Boolean = {
     var ys1 = xs1
     var ys2 = xs2
diff --git a/test/files/continuations-neg/t5314-missing-result-type.check b/test/files/continuations-neg/t5314-missing-result-type.check
new file mode 100644
index 0000000000..341e580cf3
--- /dev/null
+++ b/test/files/continuations-neg/t5314-missing-result-type.check
@@ -0,0 +1,4 @@
+t5314-missing-result-type.scala:6: error: method bar has return statement; needs result type
+  def bar(x:Int) = return foo(x)
+                   ^
+one error found
diff --git a/test/files/continuations-neg/t5314-missing-result-type.scala b/test/files/continuations-neg/t5314-missing-result-type.scala
new file mode 100644
index 0000000000..d7c5043a86
--- /dev/null
+++ b/test/files/continuations-neg/t5314-missing-result-type.scala
@@ -0,0 +1,13 @@
+import scala.util.continuations._
+
+object Test extends App {
+  def foo(x:Int): Int @cps[Int] = x
+
+  def bar(x:Int) = return foo(x)
+
+  reset {
+    val res = bar(8)
+    println(res)
+    res
+  }
+}
diff --git a/test/files/continuations-neg/t5314-npe.check b/test/files/continuations-neg/t5314-npe.check
new file mode 100644
index 0000000000..b5f024aa89
--- /dev/null
+++ b/test/files/continuations-neg/t5314-npe.check
@@ -0,0 +1,4 @@
+t5314-npe.scala:2: error: method bar has return statement; needs result type
+  def bar(x:Int) = { return x; x }  // NPE
+                     ^
+one error found
diff --git a/test/files/continuations-neg/t5314-npe.scala b/test/files/continuations-neg/t5314-npe.scala
new file mode 100644
index 0000000000..2b5966e07c
--- /dev/null
+++ b/test/files/continuations-neg/t5314-npe.scala
@@ -0,0 +1,3 @@
+object Test extends App {
+  def bar(x:Int) = { return x; x }  // NPE
+}
diff --git a/test/files/continuations-neg/t5314-return-reset.check b/test/files/continuations-neg/t5314-return-reset.check
new file mode 100644
index 0000000000..4c817ae14d
--- /dev/null
+++ b/test/files/continuations-neg/t5314-return-reset.check
@@ -0,0 +1,4 @@
+t5314-return-reset.scala:14: error: return expression not allowed, since method calls CPS method
+      if (rnd.nextInt(100) > 50) return 5 // not allowed, since method is calling `reset`
+                                 ^
+one error found
diff --git a/test/files/continuations-neg/t5314-return-reset.scala b/test/files/continuations-neg/t5314-return-reset.scala
new file mode 100644
index 0000000000..df9d58e4cb
--- /dev/null
+++ b/test/files/continuations-neg/t5314-return-reset.scala
@@ -0,0 +1,21 @@
+import scala.util.continuations._
+import scala.util.Random
+
+object Test extends App {
+  val rnd = new Random
+
+  def foo(x: Int): Int @cps[Int] = shift { k => k(x) }
+
+  def bar(x: Int): Int @cps[Int] = return foo(x)
+
+  def caller(): Int = {
+    val v: Int = reset {
+      val res: Int = bar(8)
+      if (rnd.nextInt(100) > 50) return 5 // not allowed, since method is calling `reset`
+      42
+    }
+    v
+  }
+
+  caller()
+}
diff --git a/test/files/continuations-neg/t5314-type-error.check b/test/files/continuations-neg/t5314-type-error.check
new file mode 100644
index 0000000000..1f4e46a7f2
--- /dev/null
+++ b/test/files/continuations-neg/t5314-type-error.check
@@ -0,0 +1,6 @@
+t5314-type-error.scala:7: error: type mismatch;
+ found   : Int @util.continuations.cps[Int]
+ required: Int @util.continuations.cps[String]
+  def bar(x:Int): Int @cps[String] = return foo(x)
+                                               ^
+one error found
diff --git a/test/files/continuations-neg/t5314-type-error.scala b/test/files/continuations-neg/t5314-type-error.scala
new file mode 100644
index 0000000000..e36ce6c203
--- /dev/null
+++ b/test/files/continuations-neg/t5314-type-error.scala
@@ -0,0 +1,17 @@
+import scala.util.continuations._
+
+object Test extends App {
+  def foo(x:Int): Int @cps[Int] = shift { k => k(x) }
+
+  // should be a type error
+  def bar(x:Int): Int @cps[String] = return foo(x)
+
+  def caller(): Unit = {
+    val v: String = reset {
+      val res: Int = bar(8)
+      "hello"
+    }
+  }
+
+  caller()
+}
diff --git a/test/files/continuations-run/t5314-2.check b/test/files/continuations-run/t5314-2.check
new file mode 100644
index 0000000000..35b3c93780
--- /dev/null
+++ b/test/files/continuations-run/t5314-2.check
@@ -0,0 +1,5 @@
+8
+hi
+8
+from try
+8
diff --git a/test/files/continuations-run/t5314-2.scala b/test/files/continuations-run/t5314-2.scala
new file mode 100644
index 0000000000..8a896dec2c
--- /dev/null
+++ b/test/files/continuations-run/t5314-2.scala
@@ -0,0 +1,44 @@
+import scala.util.continuations._
+
+class ReturnRepro { 
+  def s1: Int @cps[Any] = shift { k => k(5) } 
+  def caller = reset { println(p(3)) }
+  def caller2 = reset { println(p2(3)) }
+  def caller3 = reset { println(p3(3)) }
+
+  def p(i: Int): Int @cps[Any] = { 
+    val v= s1 + 3 
+    return v 
+  } 
+
+  def p2(i: Int): Int @cps[Any] = {
+    val v = s1 + 3
+    if (v > 0) {
+      println("hi")
+      return v
+    } else {
+      println("hi")
+      return 8
+    }
+  }
+
+  def p3(i: Int): Int @cps[Any] = {
+    val v = s1 + 3
+    try {
+      println("from try")
+      return v
+    } catch {
+      case e: Exception =>
+        println("from catch")
+        return 7
+    }
+  }
+
+}
+
+object Test extends App {
+  val repro = new ReturnRepro
+  repro.caller
+  repro.caller2
+  repro.caller3
+}
diff --git a/test/files/continuations-run/t5314-3.check b/test/files/continuations-run/t5314-3.check
new file mode 100644
index 0000000000..71489f097c
--- /dev/null
+++ b/test/files/continuations-run/t5314-3.check
@@ -0,0 +1,4 @@
+enter return expr
+8
+hi
+8
diff --git a/test/files/continuations-run/t5314-3.scala b/test/files/continuations-run/t5314-3.scala
new file mode 100644
index 0000000000..62c547f5a2
--- /dev/null
+++ b/test/files/continuations-run/t5314-3.scala
@@ -0,0 +1,27 @@
+import scala.util.continuations._
+
+class ReturnRepro { 
+  def s1: Int @cpsParam[Any, Unit] = shift { k => k(5) } 
+  def caller = reset { println(p(3)) }
+  def caller2 = reset { println(p2(3)) }
+
+  def p(i: Int): Int @cpsParam[Unit, Any] = { 
+    val v= s1 + 3 
+    return { println("enter return expr"); v }
+  } 
+
+  def p2(i: Int): Int @cpsParam[Unit, Any] = {
+    val v = s1 + 3
+    if (v > 0) {
+      return { println("hi"); v }
+    } else {
+      return { println("hi"); 8 }
+    }
+  }
+}
+
+object Test extends App {
+  val repro = new ReturnRepro
+  repro.caller
+  repro.caller2
+}
diff --git a/test/files/continuations-run/t5314-with-if.check b/test/files/continuations-run/t5314-with-if.check
new file mode 100644
index 0000000000..7f8f011eb7
--- /dev/null
+++ b/test/files/continuations-run/t5314-with-if.check
@@ -0,0 +1 @@
+7
diff --git a/test/files/continuations-run/t5314-with-if.scala b/test/files/continuations-run/t5314-with-if.scala
new file mode 100644
index 0000000000..5840199a3c
--- /dev/null
+++ b/test/files/continuations-run/t5314-with-if.scala
@@ -0,0 +1,17 @@
+import scala.util.continuations._
+
+object Test extends App {
+
+  def foo(x:Int): Int @cps[Int] = 7
+
+  def bar(x:Int): Int @cps[Int] = {
+    val v = foo(x)
+    if (v > 0)
+      return v
+    else
+      return 10
+  }
+
+  println(reset { bar(10) })
+
+}
diff --git a/test/files/continuations-run/t5314.check b/test/files/continuations-run/t5314.check
new file mode 100644
index 0000000000..4b35d8e6d0
--- /dev/null
+++ b/test/files/continuations-run/t5314.check
@@ -0,0 +1,8 @@
+7
+7
+7
+8
+8
+hi
+8
+8
diff --git a/test/files/continuations-run/t5314.scala b/test/files/continuations-run/t5314.scala
new file mode 100644
index 0000000000..d611016ce4
--- /dev/null
+++ b/test/files/continuations-run/t5314.scala
@@ -0,0 +1,52 @@
+import scala.util.continuations._
+
+class ReturnRepro { 
+  def s1: Int @cpsParam[Any, Unit] = shift { k => k(5) } 
+  def caller = reset { println(p(3)) }
+  def caller2 = reset { println(p2(3)) }
+
+  def p(i: Int): Int @cpsParam[Unit, Any] = { 
+    val v= s1 + 3 
+    return v 
+  } 
+
+  def p2(i: Int): Int @cpsParam[Unit, Any] = {
+    val v = s1 + 3
+    if (v > 0) {
+      println("hi")
+      return v
+    } else {
+      println("hi")
+      return 8
+    }
+  }
+}
+
+object Test extends App {
+  def foo(x:Int): Int @cps[Int] = shift { k => k(x) }
+
+  def bar(x:Int): Int @cps[Int] = return foo(x)
+
+  def nocps(x: Int): Int = { return x; x }
+
+  def foo2(x:Int): Int @cps[Int] = 7
+  def bar2(x:Int): Int @cps[Int] = { foo2(x); return 7 }
+  def bar3(x:Int): Int @cps[Int] = { foo2(x); if (x == 7) return 7 else return foo2(x) }
+  def bar4(x:Int): Int @cps[Int] = { foo2(x); if (x == 7) return 7 else foo2(x) }
+  def bar5(x:Int): Int @cps[Int] = { foo2(x); if (x == 7) return 7 else 8 }
+  println(reset { bar2(10) })
+  println(reset { bar3(10) })
+  println(reset { bar4(10) })
+  println(reset { bar5(10) })
+  
+  /* original test case */
+  val repro = new ReturnRepro
+  repro.caller
+  repro.caller2
+
+  reset {
+    val res = bar(8)
+    println(res)
+    res
+  }
+}
diff --git a/test/files/neg/patmat-type-check.check b/test/files/neg/patmat-type-check.check
index e045841ce1..721217c314 100644
--- a/test/files/neg/patmat-type-check.check
+++ b/test/files/neg/patmat-type-check.check
@@ -1,3 +1,12 @@
+patmat-type-check.scala:11: warning: fruitless type test: a value of type Test.Bop4[T] cannot also be a Seq[A]
+  def s3[T](x: Bop4[T]) = x match { case Seq('b', 'o', 'b') => true }
+                                            ^
+patmat-type-check.scala:15: warning: fruitless type test: a value of type Test.Bop5[_$1,T1,T2] cannot also be a Seq[A]
+  def s4[T1, T2](x: Bop5[_, T1, T2]) = x match { case Seq('b', 'o', 'b') => true }
+                                                         ^
+patmat-type-check.scala:19: warning: fruitless type test: a value of type Test.Bop3[T] cannot also be a Seq[A]
+  def f4[T](x: Bop3[T]) = x match { case Seq('b', 'o', 'b') => true }
+                                            ^
 patmat-type-check.scala:22: error: scrutinee is incompatible with pattern type;
  found   : Seq[A]
  required: String
@@ -18,4 +27,5 @@ patmat-type-check.scala:30: error: scrutinee is incompatible with pattern type;
  required: Test.Bop3[Char]
   def f4[T](x: Bop3[Char]) = x match { case Seq('b', 'o', 'b') => true } // fail
                                                ^
+three warnings found
 four errors found
diff --git a/test/files/neg/t1872.check b/test/files/neg/t1872.check
index ef84ef79e0..c5dc2a8080 100644
--- a/test/files/neg/t1872.check
+++ b/test/files/neg/t1872.check
@@ -1,4 +1,8 @@
+t1872.scala:3: warning: fruitless type test: a value of type Int cannot also be a scala.util.Random
+  def f(x: Int) = x.isInstanceOf[util.Random]
+                                ^
 t1872.scala:3: error: isInstanceOf cannot test if value types are references.
   def f(x: Int) = x.isInstanceOf[util.Random]
                     ^
+one warning found
 one error found
diff --git a/test/files/neg/t4302.check b/test/files/neg/t4302.check
index 327425acb0..450d28bbc5 100644
--- a/test/files/neg/t4302.check
+++ b/test/files/neg/t4302.check
@@ -1,4 +1,4 @@
-t4302.scala:2: error: abstract type T in type T is unchecked since it is eliminated by erasure
+t4302.scala:2: error: abstract type T is unchecked since it is eliminated by erasure
   def hasMatch[T](x: AnyRef) = x.isInstanceOf[T]
                                              ^
 one error found
diff --git a/test/files/neg/t5762.check b/test/files/neg/t5762.check
new file mode 100644
index 0000000000..10064032aa
--- /dev/null
+++ b/test/files/neg/t5762.check
@@ -0,0 +1,13 @@
+t5762.scala:6: error: non-variable type argument Int in type pattern D[Int] is unchecked since it is eliminated by erasure
+    case _: D[Int]    if bippy => 1
+            ^
+t5762.scala:7: error: non-variable type argument String in type pattern D[String] is unchecked since it is eliminated by erasure
+    case _: D[String]          => 2
+            ^
+t5762.scala:20: error: non-variable type argument D[Int] in type pattern D[D[Int]] is unchecked since it is eliminated by erasure
+    case _: D[D[Int]]    if bippy => 1
+            ^
+t5762.scala:21: error: non-variable type argument D[String] in type pattern D[D[String]] is unchecked since it is eliminated by erasure
+    case _: D[D[String]]          => 2
+            ^
+four errors found
diff --git a/test/files/neg/t5762.flags b/test/files/neg/t5762.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/t5762.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/t5762.scala b/test/files/neg/t5762.scala
new file mode 100644
index 0000000000..fb73552b12
--- /dev/null
+++ b/test/files/neg/t5762.scala
@@ -0,0 +1,24 @@
+class D[-A]
+
+object Test {
+  var bippy: Boolean = true
+  def f1(x: D[Int with String]) = x match {
+    case _: D[Int]    if bippy => 1
+    case _: D[String]          => 2
+  }
+  // Correctly warns:
+  //
+  // a.scala:5: warning: non variable type-argument Int in type pattern D[Int] is unchecked since it is eliminated by erasure
+  //     case _: D[Int]    => 1
+  //             ^
+  // a.scala:6: warning: non variable type-argument String in type pattern D[String] is unchecked since it is eliminated by erasure
+  //     case _: D[String] => 2
+  //             ^
+  // two warnings found
+
+  def f2(x: D[D[Int] with D[String]]) = x match {
+    case _: D[D[Int]]    if bippy => 1
+    case _: D[D[String]]          => 2
+  }
+  // No warnings!
+}
diff --git a/test/files/neg/unchecked-abstract.check b/test/files/neg/unchecked-abstract.check
new file mode 100644
index 0000000000..dc7a8d93d0
--- /dev/null
+++ b/test/files/neg/unchecked-abstract.check
@@ -0,0 +1,25 @@
+unchecked-abstract.scala:16: error: abstract type H in type Con[M.this.H] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Con[H]])
+                                       ^
+unchecked-abstract.scala:21: error: abstract type H in type Con[M.this.H] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Con[H]])
+                                       ^
+unchecked-abstract.scala:27: error: abstract type T in type Inv[M.this.T] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Inv[T]])
+                                       ^
+unchecked-abstract.scala:28: error: abstract type L in type Inv[M.this.L] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Inv[L]])
+                                       ^
+unchecked-abstract.scala:31: error: abstract type H in type Inv[M.this.H] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Inv[H]])
+                                       ^
+unchecked-abstract.scala:33: error: abstract type L in type Inv[M.this.L] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Inv[L]])
+                                       ^
+unchecked-abstract.scala:36: error: abstract type H in type Inv[M.this.H] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Inv[H]])
+                                       ^
+unchecked-abstract.scala:37: error: abstract type T in type Inv[M.this.T] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Inv[T]])
+                                       ^
+8 errors found
diff --git a/test/files/neg/unchecked-abstract.flags b/test/files/neg/unchecked-abstract.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/unchecked-abstract.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/unchecked-abstract.scala b/test/files/neg/unchecked-abstract.scala
new file mode 100644
index 0000000000..5b915755f4
--- /dev/null
+++ b/test/files/neg/unchecked-abstract.scala
@@ -0,0 +1,93 @@
+trait Con[-X]
+trait Inv[X]
+trait Cov[+X]
+
+abstract class M {
+  type H
+  type L <: H
+  type T >: L <: H
+
+  def h1(x: Con[H]) = {
+    /* nowarn */ println(x.isInstanceOf[Con[H]])
+    /* nowarn */ println(x.isInstanceOf[Con[T]])
+    /* nowarn */ println(x.isInstanceOf[Con[L]])
+  }
+  def h2(x: Con[T]) = {
+    /*   warn */ println(x.isInstanceOf[Con[H]])
+    /* nowarn */ println(x.isInstanceOf[Con[T]])
+    /* nowarn */ println(x.isInstanceOf[Con[L]])
+  }
+  def h3(x: Con[L]) = {
+    /*   warn */ println(x.isInstanceOf[Con[H]])
+    /*   warn */ println(x.isInstanceOf[Con[T]])
+    /* nowarn */ println(x.isInstanceOf[Con[L]])
+  }
+  def h4(x: Inv[H]) = {
+    /* nowarn */ println(x.isInstanceOf[Inv[H]])
+    /*   warn */ println(x.isInstanceOf[Inv[T]])
+    /*   warn */ println(x.isInstanceOf[Inv[L]])
+  }
+  def h5(x: Inv[T]) = {
+    /*   warn */ println(x.isInstanceOf[Inv[H]])
+    /* nowarn */ println(x.isInstanceOf[Inv[T]])
+    /*   warn */ println(x.isInstanceOf[Inv[L]])
+  }
+  def h6(x: Inv[L]) = {
+    /*   warn */ println(x.isInstanceOf[Inv[H]])
+    /*   warn */ println(x.isInstanceOf[Inv[T]])
+    /* nowarn */ println(x.isInstanceOf[Inv[L]])
+  }
+  def h7(x: Cov[H]) = {
+    /* nowarn */ println(x.isInstanceOf[Cov[H]])
+    /*   warn */ println(x.isInstanceOf[Cov[T]])
+    /*   warn */ println(x.isInstanceOf[Cov[L]])
+  }
+  def h8(x: Cov[T]) = {
+    /* nowarn */ println(x.isInstanceOf[Cov[H]])
+    /* nowarn */ println(x.isInstanceOf[Cov[T]])
+    /*   warn */ println(x.isInstanceOf[Cov[L]])
+  }
+  def h9(x: Cov[L]) = {
+    /* nowarn */ println(x.isInstanceOf[Cov[H]])
+    /* nowarn */ println(x.isInstanceOf[Cov[T]])
+    /* nowarn */ println(x.isInstanceOf[Cov[L]])
+  }
+}
+
+object Test extends M {
+  type H = Any
+  type T = Int
+  type L = Nothing
+
+  val conh = new Con[H] { }
+  val cont = new Con[T] { }
+  val conl = new Con[L] { }
+
+  val invh = new Inv[H] { }
+  val invt = new Inv[T] { }
+  val invl = new Inv[L] { }
+
+  val covh = new Cov[H] { }
+  val covt = new Cov[T] { }
+  val covl = new Cov[L] { }
+
+  def main(args: Array[String]): Unit = {
+    h1(conh)
+    h2(conh)
+    h2(cont)
+    h3(conh)
+    h3(cont)
+    h3(conl)
+
+    h4(invh)
+    h5(invt)
+    h6(invl)
+
+    h7(covh)
+    h7(covt)
+    h7(covl)
+    h8(covt)
+    h8(covl)
+    h9(covl)
+  }
+}
diff --git a/test/files/neg/unchecked-impossible.check b/test/files/neg/unchecked-impossible.check
new file mode 100644
index 0000000000..0ab371dbaa
--- /dev/null
+++ b/test/files/neg/unchecked-impossible.check
@@ -0,0 +1,4 @@
+unchecked-impossible.scala:5: error: fruitless type test: a value of type T2[Int,Int] cannot also be a Seq[A]
+    case Seq(x) =>
+            ^
+one error found
diff --git a/test/files/neg/unchecked-impossible.flags b/test/files/neg/unchecked-impossible.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/unchecked-impossible.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/unchecked-impossible.scala b/test/files/neg/unchecked-impossible.scala
new file mode 100644
index 0000000000..985a2d0b08
--- /dev/null
+++ b/test/files/neg/unchecked-impossible.scala
@@ -0,0 +1,16 @@
+final case class T2[+A, +B](a: A, b: B)
+
+class A {
+  def f1 = T2(1, 2) match {
+    case Seq(x) =>
+    case _      =>
+  }
+  def f2 = T2(1, 2) match {
+    case _: T2[Int, Int] => /* nowarn */
+    case _               =>
+  }
+  def f3 = T2(1, 2) match {
+    case _: T2[_, Int] => /* nowarn */
+    case _             =>
+  }
+}
diff --git a/test/files/neg/unchecked-knowable.check b/test/files/neg/unchecked-knowable.check
new file mode 100644
index 0000000000..3a6ef994b5
--- /dev/null
+++ b/test/files/neg/unchecked-knowable.check
@@ -0,0 +1,4 @@
+unchecked-knowable.scala:17: error: fruitless type test: a value of type Bippy cannot also be a A1
+  /*   warn */ (new Bippy).isInstanceOf[A1]
+                                       ^
+one error found
diff --git a/test/files/neg/unchecked-knowable.flags b/test/files/neg/unchecked-knowable.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/unchecked-knowable.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/unchecked-knowable.scala b/test/files/neg/unchecked-knowable.scala
new file mode 100644
index 0000000000..667b47f504
--- /dev/null
+++ b/test/files/neg/unchecked-knowable.scala
@@ -0,0 +1,20 @@
+/** Knowable - only final leaves */
+sealed abstract class A1
+sealed abstract class A2 extends A1
+final class A3 extends A1
+final class A4 extends A2
+
+/** Unknowable */
+sealed abstract class B1
+sealed abstract class B2 extends B1
+final class B3 extends B1
+trait B4 extends B2
+
+class Bippy
+trait Dingus
+
+class A {
+  /*   warn */ (new Bippy).isInstanceOf[A1]
+  /* nowarn */ (new Bippy).isInstanceOf[B1]
+  /* nowarn */ ((new Bippy): Any).isInstanceOf[A1]
+}
diff --git a/test/files/neg/unchecked-refinement.check b/test/files/neg/unchecked-refinement.check
new file mode 100644
index 0000000000..d81517464f
--- /dev/null
+++ b/test/files/neg/unchecked-refinement.check
@@ -0,0 +1,13 @@
+unchecked-refinement.scala:17: error: abstract type U in type pattern Foo[U,U,V] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Foo[U, U, V] if b       => ()
+                         ^
+unchecked-refinement.scala:19: error: non-variable type argument Any in type pattern Foo[Any,U,V] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Foo[Any, U, V] if b     => ()
+                         ^
+unchecked-refinement.scala:23: error: a pattern match on a refinement type is unchecked
+    /* nowarn - todo */ case x: AnyRef { def bippy: Int } if b => x.bippy  // this could/should do an instance check and not warn
+                                ^
+unchecked-refinement.scala:24: error: a pattern match on a refinement type is unchecked
+    /* nowarn - todo */ case x: AnyRef { def size: Int } if b  => x.size   // this could/should do a static conformance test and not warn
+                                ^
+four errors found
diff --git a/test/files/neg/unchecked-refinement.flags b/test/files/neg/unchecked-refinement.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/unchecked-refinement.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/unchecked-refinement.scala b/test/files/neg/unchecked-refinement.scala
new file mode 100644
index 0000000000..79ed7f13c1
--- /dev/null
+++ b/test/files/neg/unchecked-refinement.scala
@@ -0,0 +1,27 @@
+// a.scala
+// Thu Sep 27 09:42:16 PDT 2012
+
+trait Bar[-T1, T2, +T3] { }
+trait Foo[-T1, T2, +T3] extends Bar[T1, T2, T3]
+
+class A {
+  var b = true
+
+  def f1(x: Foo[Int, Int, Int]) = x match {
+    /* nowarn */ case _: Foo[Nothing, Int, Any] => true
+  }
+  def f2[T, U, V](x: Foo[T, U, V]) = x match {
+    /* nowarn */ case _: Foo[Nothing, U, Any] => true
+  }
+  def f3[T, U, V](x: Foo[T, U, V]) = x match {
+    /*   warn */ case _: Foo[U, U, V] if b       => ()
+    /* nowarn */ case _: Foo[Nothing, U, V] if b => ()
+    /*   warn */ case _: Foo[Any, U, V] if b     => ()
+  }
+
+  def f4(xs: List[Int]) = xs match {
+    /* nowarn - todo */ case x: AnyRef { def bippy: Int } if b => x.bippy  // this could/should do an instance check and not warn
+    /* nowarn - todo */ case x: AnyRef { def size: Int } if b  => x.size   // this could/should do a static conformance test and not warn
+    /* nowarn */ case x: ((AnyRef { def size: Int }) @unchecked) if b  => x.size
+  }
+}
diff --git a/test/files/neg/unchecked.check b/test/files/neg/unchecked.check
index 34a11db1a0..2883b716c9 100644
--- a/test/files/neg/unchecked.check
+++ b/test/files/neg/unchecked.check
@@ -2,7 +2,7 @@ unchecked.scala:18: error: non-variable type argument String in type pattern Ite
     case xs: Iterable[String] => xs.head // unchecked
              ^
 unchecked.scala:22: error: non-variable type argument Any in type pattern Set[Any] is unchecked since it is eliminated by erasure
-    case xs: Set[Any]    => xs.head // unchecked
+    case xs: Set[Any] => xs.head // unchecked
              ^
 unchecked.scala:26: error: non-variable type argument Any in type pattern Map[Any,Any] is unchecked since it is eliminated by erasure
     case xs: Map[Any, Any] => xs.head // unchecked
diff --git a/test/files/neg/unchecked.scala b/test/files/neg/unchecked.scala
index b50cdf9d7a..e491b253ba 100644
--- a/test/files/neg/unchecked.scala
+++ b/test/files/neg/unchecked.scala
@@ -19,8 +19,8 @@ object Test {
     case _                    => 0
   }
   def f3(x: Any) = x match {
-    case xs: Set[Any]    => xs.head // unchecked
-    case _                    => 0
+    case xs: Set[Any] => xs.head // unchecked
+    case _            => 0
   }
   def f4(x: Any) = x match {
     case xs: Map[Any, Any] => xs.head // unchecked
diff --git a/test/files/neg/unchecked2.check b/test/files/neg/unchecked2.check
index e37865928e..68fdfa82ac 100644
--- a/test/files/neg/unchecked2.check
+++ b/test/files/neg/unchecked2.check
@@ -1,19 +1,43 @@
-unchecked2.scala:2: error: non-variable type argument Int in type Option[Int] is unchecked since it is eliminated by erasure
-  Some(123).isInstanceOf[Option[Int]]
-                        ^
-unchecked2.scala:3: error: non-variable type argument String in type Option[String] is unchecked since it is eliminated by erasure
-  Some(123).isInstanceOf[Option[String]]
-                        ^
-unchecked2.scala:4: error: non-variable type argument List[String] in type Option[List[String]] is unchecked since it is eliminated by erasure
-  Some(123).isInstanceOf[Option[List[String]]]
-                        ^
-unchecked2.scala:5: error: non-variable type argument List[Int => String] in type Option[List[Int => String]] is unchecked since it is eliminated by erasure
-  Some(123).isInstanceOf[Option[List[Int => String]]]
-                        ^
-unchecked2.scala:6: error: non-variable type argument (String, Double) in type Option[(String, Double)] is unchecked since it is eliminated by erasure
-  Some(123).isInstanceOf[Option[(String, Double)]]
-                        ^
-unchecked2.scala:7: error: non-variable type argument String => Double in type Option[String => Double] is unchecked since it is eliminated by erasure
-  Some(123).isInstanceOf[Option[String => Double]]
-                        ^
-6 errors found
+unchecked2.scala:4: error: fruitless type test: a value of type Some[List[Int]] cannot also be a Option[List[String]] (but still might match its erasure)
+  /*   warn */ Some(List(1)).isInstanceOf[Option[List[String]]]
+                                         ^
+unchecked2.scala:5: error: non-variable type argument Option[_] in type Option[Option[_]] is unchecked since it is eliminated by erasure
+  /*   warn */ Some(123).isInstanceOf[Option[Option[_]]]
+                                     ^
+unchecked2.scala:6: error: fruitless type test: a value of type Some[Int] cannot also be a Option[String] (but still might match its erasure)
+  /*   warn */ Some(123).isInstanceOf[Option[String]]
+                                     ^
+unchecked2.scala:7: error: fruitless type test: a value of type Some[Int] cannot also be a Option[List[String]] (but still might match its erasure)
+  /*   warn */ Some(123).isInstanceOf[Option[List[String]]]
+                                     ^
+unchecked2.scala:8: error: fruitless type test: a value of type Some[Int] cannot also be a Option[List[Int => String]] (but still might match its erasure)
+  /*   warn */ Some(123).isInstanceOf[Option[List[Int => String]]]
+                                     ^
+unchecked2.scala:9: error: fruitless type test: a value of type Some[Int] cannot also be a Option[(String, Double)] (but still might match its erasure)
+  /*   warn */ Some(123).isInstanceOf[Option[(String, Double)]]
+                                     ^
+unchecked2.scala:10: error: fruitless type test: a value of type Some[Int] cannot also be a Option[String => Double] (but still might match its erasure)
+  /*   warn */ Some(123).isInstanceOf[Option[String => Double]]
+                                     ^
+unchecked2.scala:14: error: non-variable type argument List[String] in type Option[List[String]] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(List(1)): Any).isInstanceOf[Option[List[String]]]
+                                                ^
+unchecked2.scala:15: error: non-variable type argument Int in type Option[Int] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[Int]]
+                                            ^
+unchecked2.scala:16: error: non-variable type argument String in type Option[String] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[String]]
+                                            ^
+unchecked2.scala:17: error: non-variable type argument List[String] in type Option[List[String]] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[List[String]]]
+                                            ^
+unchecked2.scala:18: error: non-variable type argument List[Int => String] in type Option[List[Int => String]] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[List[Int => String]]]
+                                            ^
+unchecked2.scala:19: error: non-variable type argument (String, Double) in type Option[(String, Double)] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[(String, Double)]]
+                                            ^
+unchecked2.scala:20: error: non-variable type argument String => Double in type Option[String => Double] is unchecked since it is eliminated by erasure
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[String => Double]]
+                                            ^
+14 errors found
diff --git a/test/files/neg/unchecked2.scala b/test/files/neg/unchecked2.scala
index a2e757e1dc..616b05aad8 100644
--- a/test/files/neg/unchecked2.scala
+++ b/test/files/neg/unchecked2.scala
@@ -1,8 +1,33 @@
 object Test {
-  Some(123).isInstanceOf[Option[Int]]
-  Some(123).isInstanceOf[Option[String]]
-  Some(123).isInstanceOf[Option[List[String]]]
-  Some(123).isInstanceOf[Option[List[Int => String]]]
-  Some(123).isInstanceOf[Option[(String, Double)]]
-  Some(123).isInstanceOf[Option[String => Double]]
+  // These warn because it can be statically shown they won't match.
+
+  /*   warn */ Some(List(1)).isInstanceOf[Option[List[String]]]
+  /*   warn */ Some(123).isInstanceOf[Option[Option[_]]]
+  /*   warn */ Some(123).isInstanceOf[Option[String]]
+  /*   warn */ Some(123).isInstanceOf[Option[List[String]]]
+  /*   warn */ Some(123).isInstanceOf[Option[List[Int => String]]]
+  /*   warn */ Some(123).isInstanceOf[Option[(String, Double)]]
+  /*   warn */ Some(123).isInstanceOf[Option[String => Double]]
+
+  // These warn because you can't check at runtime.
+
+  /*   warn */ (Some(List(1)): Any).isInstanceOf[Option[List[String]]]
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[Int]]
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[String]]
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[List[String]]]
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[List[Int => String]]]
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[(String, Double)]]
+  /*   warn */ (Some(123): Any).isInstanceOf[Option[String => Double]]
+
+  // These don't warn.
+
+  /* nowarn */ Some(List(1)).isInstanceOf[Option[List[Int]]]
+  /* nowarn */ Some(123).isInstanceOf[Option[Int]]
+  /* nowarn */ Some(123).isInstanceOf[Some[Int]]
+  /* nowarn */ Some(123).isInstanceOf[AnyRef]
+
+  /* nowarn */ (Some(List(1)): Any).isInstanceOf[Option[_]]
+  /* nowarn */ (Some(123): Any).isInstanceOf[Option[_]]
+  /* nowarn */ (Some(123): Any).isInstanceOf[Some[_]]
+  /* nowarn */ (Some(123): Any).isInstanceOf[AnyRef]
 }
diff --git a/test/files/neg/unchecked3.check b/test/files/neg/unchecked3.check
new file mode 100644
index 0000000000..f4f0c74257
--- /dev/null
+++ b/test/files/neg/unchecked3.check
@@ -0,0 +1,37 @@
+unchecked3.scala:24: error: non-variable type argument Double in type pattern E1[Double] is unchecked since it is eliminated by erasure
+  /*   warn */ def peerTypes2(x: B1[Int]) = x match { case _: E1[Double] => true }
+                                                              ^
+unchecked3.scala:25: error: non-variable type argument Double in type pattern F1[Double] is unchecked since it is eliminated by erasure
+  /*   warn */ def peerTypes3(x: B1[_]) = x match { case _: F1[Double] => true }
+                                                            ^
+unchecked3.scala:28: error: non-variable type argument Int in type pattern A2[Int] is unchecked since it is eliminated by erasure
+  /*   warn */ def twotypes1[T](x: B2[T, Int]) = x match { case _: A2[Int] => true }
+                                                                   ^
+unchecked3.scala:32: error: non-variable type argument Int in type pattern B2[_,Int] is unchecked since it is eliminated by erasure
+  /*   warn */ def twotypes5[T](x: A2[T]) = x match { case _: B2[_, Int] => true }
+                                                              ^
+unchecked3.scala:40: error: non-variable type argument String in type pattern Array[List[String]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[List[String]]         => ()
+                         ^
+unchecked3.scala:43: error: non-variable type argument String in type pattern Array[Array[List[String]]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[Array[List[String]]]  => ()
+                         ^
+unchecked3.scala:50: error: non-variable type argument String in type pattern Array[List[String]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[List[String]]         => ()
+                         ^
+unchecked3.scala:53: error: non-variable type argument String in type pattern Array[Array[List[String]]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[Array[List[String]]]  => ()
+                         ^
+unchecked3.scala:60: error: non-variable type argument String in type pattern Array[List[String]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[List[String]]        => ()
+                         ^
+unchecked3.scala:62: error: non-variable type argument Array[String] in type pattern Array[List[Array[String]]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[List[Array[String]]] => ()
+                         ^
+unchecked3.scala:63: error: non-variable type argument String in type pattern Array[Array[List[String]]] is unchecked since it is eliminated by erasure
+    /*   warn */ case _: Array[Array[List[String]]] => ()
+                         ^
+unchecked3.scala:75: error: abstract type A in type pattern Set[Q.this.A] is unchecked since it is eliminated by erasure
+      /*   warn */ case xs: Set[A]  => xs.head
+                            ^
+12 errors found
diff --git a/test/files/neg/unchecked3.flags b/test/files/neg/unchecked3.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/unchecked3.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/unchecked3.scala b/test/files/neg/unchecked3.scala
new file mode 100644
index 0000000000..7b8c13e8f8
--- /dev/null
+++ b/test/files/neg/unchecked3.scala
@@ -0,0 +1,83 @@
+sealed trait A2[T1]
+final class B2[T1, T2] extends A2[T1]
+
+sealed trait A[T]
+final class B[T] extends A[T]
+
+sealed trait A1[T]
+trait B1[T] extends A1[T]
+trait C1[T] extends A1[T]
+trait D1[T] extends A1[Int]
+trait E1[T] extends B1[Int]
+trait F1[T] extends B1[T]
+
+object MiscUnchecked {
+  /* nowarn */ def knownType1(x: A[Int])  = x match { case _: B[Int] if true => 1 }
+  /* nowarn */ def knownType2(x: B[Int])  = x match { case _: A[Int] if true => 1 }
+  /* nowarn */ def tparamLeakage1(x: Any) = x match { case Array() => 1 }
+  /* nowarn */ def tparamLeakage2(x: Any) = x match { case List() => 1 }
+
+  // E1[Double] implies B1[Int], but B1[Int] does not imply E1[Double], even if .isInstanceOf[E1[_]]
+  // F1[Int] implies B1[Int], and B1[Int] implies F1[Int]
+
+  /* nowarn */ def peerTypes1(x: B1[Int]) = x match { case _: C1[Int] => true }
+  /*   warn */ def peerTypes2(x: B1[Int]) = x match { case _: E1[Double] => true }
+  /*   warn */ def peerTypes3(x: B1[_]) = x match { case _: F1[Double] => true }
+  /* nowarn */ def peerTypes4(x: B1[Int]) = x match { case _: F1[Int] => true }
+
+  /*   warn */ def twotypes1[T](x: B2[T, Int]) = x match { case _: A2[Int] => true }
+  /* nowarn */ def twotypes2[T](x: B2[Int, T]) = x match { case _: A2[Int] => true }
+  /* nowarn */ def twotypes3(x: A2[Int]) = x match { case _: B2[Int, _] => true }
+  /* nowarn */ def twotypes4[T](x: A2[T]) = x match { case _: B2[T, _] => true }
+  /*   warn */ def twotypes5[T](x: A2[T]) = x match { case _: B2[_, Int] => true }
+}
+
+object Arrays {
+  def f1(x: Any) = x match {
+    /* nowarn */ case _: Array[Int]                  => ()
+    /* nowarn */ case _: Array[Boolean]              => ()
+    /* nowarn */ case _: Array[String]               => ()
+    /*   warn */ case _: Array[List[String]]         => ()
+    /* nowarn */ case _: Array[Array[String]]        => ()
+    /* nowarn */ case _: Array[Array[Array[String]]] => ()
+    /*   warn */ case _: Array[Array[List[String]]]  => ()
+  }
+
+  def f2(x: Array[_]) = x match {
+    /* nowarn */ case _: Array[Int]                  => ()
+    /* nowarn */ case _: Array[Boolean]              => ()
+    /* nowarn */ case _: Array[String]               => ()
+    /*   warn */ case _: Array[List[String]]         => ()
+    /* nowarn */ case _: Array[Array[String]]        => ()
+    /* nowarn */ case _: Array[Array[Array[String]]] => ()
+    /*   warn */ case _: Array[Array[List[String]]]  => ()
+  }
+
+  def f3[T](x: Array[T]) = x match {
+    /* nowarn */ case _: Array[Int]                 => ()
+    /* nowarn */ case _: Array[Boolean]             => ()
+    /* nowarn */ case _: Array[String]              => ()
+    /*   warn */ case _: Array[List[String]]        => ()
+    /* nowarn */ case _: Array[Array[String]]       => ()
+    /*   warn */ case _: Array[List[Array[String]]] => ()
+    /*   warn */ case _: Array[Array[List[String]]] => ()
+  }
+}
+
+object Matching {
+  class Q {
+    type A
+    type B <: A
+
+    def f(xs: Traversable[B]) = xs match {
+      /* nowarn */ case xs: List[A] => xs.head
+      /* nowarn */ case xs: Seq[B]  => xs.head
+      /*   warn */ case xs: Set[A]  => xs.head
+    }
+    def f2[T <: B](xs: Traversable[T]) = xs match {
+      /* nowarn */ case xs: List[B with T] => xs.head
+      /* nowarn */ case xs: Seq[A]         => xs.head
+      /* nowarn */ case xs: Set[T]         => xs.head
+    }
+  }
+}
diff --git a/test/files/pos/t1107/O.scala b/test/files/pos/t1107b/O.scala
index aa605a6d09..aa605a6d09 100644
--- a/test/files/pos/t1107/O.scala
+++ b/test/files/pos/t1107b/O.scala
diff --git a/test/files/pos/t1107/T.scala b/test/files/pos/t1107b/T.scala
index 1f3712d529..1f3712d529 100644
--- a/test/files/pos/t1107/T.scala
+++ b/test/files/pos/t1107b/T.scala
diff --git a/test/files/pos/t1203/J.java b/test/files/pos/t1203b/J.java
index 7fae118e04..7fae118e04 100644
--- a/test/files/pos/t1203/J.java
+++ b/test/files/pos/t1203b/J.java
diff --git a/test/files/pos/t1203/S.scala b/test/files/pos/t1203b/S.scala
index 68eac4bf6d..68eac4bf6d 100644
--- a/test/files/pos/t1203/S.scala
+++ b/test/files/pos/t1203b/S.scala
diff --git a/test/files/pos/t6275.flags b/test/files/pos/t6275.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/pos/t6275.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/pos/t6275.scala b/test/files/pos/t6275.scala
new file mode 100644
index 0000000000..6b5ec7dceb
--- /dev/null
+++ b/test/files/pos/t6275.scala
@@ -0,0 +1,11 @@
+
+sealed trait A[T]
+final class B[T] extends A[T]
+
+object ParsedAxis {
+  type BI = B[Int]
+
+  def f1(a: A[Int]) = a match { case b: B[Int] => 3 }
+  def f2(a: A[Int]) = a match { case b: BI => 3 }
+  def f3(a: A[Int]) = a match { case b: B[t] => 3 }
+}
diff --git a/test/files/run/fail-non-value-types.check b/test/files/run/fail-non-value-types.check
new file mode 100644
index 0000000000..714dce2c50
--- /dev/null
+++ b/test/files/run/fail-non-value-types.check
@@ -0,0 +1,3 @@
+[B, That](f: A => B)(implicit cbf: ImaginaryCanBuildFrom[CompletelyIndependentList.this.Repr,B,That])That
+[B, That](f: Int => B)(implicit cbf: ImaginaryCanBuildFrom[CompletelyIndependentList[Int]#Repr,B,That])That
+()CompletelyIndependentList[A]
diff --git a/test/files/run/fail-non-value-types.scala b/test/files/run/fail-non-value-types.scala
new file mode 100644
index 0000000000..51198a5f31
--- /dev/null
+++ b/test/files/run/fail-non-value-types.scala
@@ -0,0 +1,40 @@
+import scala.reflect.runtime.universe._
+
+class ImaginaryCanBuildFrom[-From, -Elem, +To]
+class CompletelyIndependentList[+A] {
+  type Repr <: CompletelyIndependentList[A]
+  def map[B, That](f: A => B)(implicit cbf: ImaginaryCanBuildFrom[Repr, B, That]): That = ???
+  def distinct(): CompletelyIndependentList[A] = ???
+}
+
+object Test {
+  var failed = false
+  def expectFailure[T](body: => T): Boolean = {
+    try { val res = body ; failed = true ; println(res + " failed to fail.") ; false }
+    catch { case _: AssertionError => true }
+  }
+
+  /** Attempt to use a method type as a type argument - expect failure. */
+  def tcon[T: TypeTag](args: Type*) = appliedType(typeOf[T].typeConstructor, args.toList)
+
+  def cil      = typeOf[CompletelyIndependentList[Int]]
+  def map      = cil.member("map": TermName).asMethod
+  def distinct = cil.member("distinct": TermName).asMethod
+
+  def main(args: Array[String]): Unit = {
+    // Need the assert in there to fail.
+    // expectFailure(println(tcon[CompletelyIndependentList[Int]](map)))
+    // expectFailure(tcon[CompletelyIndependentList[Int]](distinct))
+
+    // Why is the first map signature printing showing an
+    // uninitialized symbol?
+    //
+    // [B <: <?>, That <: <?>](f: <?>)(implicit cbf: <?>)That
+    //
+
+    println(map.typeSignature)
+    println(map.typeSignatureIn(cil))
+    println(distinct.typeSignature)
+    if (failed) sys.exit(1)
+  }
+}
diff --git a/test/files/run/macro-reify-type.check b/test/files/run/macro-reify-type.check
new file mode 100644
index 0000000000..ea5e70e10d
--- /dev/null
+++ b/test/files/run/macro-reify-type.check
@@ -0,0 +1 @@
+[B, That](f: Int => B)(implicit bf: scala.collection.generic.CanBuildFrom[List[Int],B,That])That
\ No newline at end of file
diff --git a/test/files/run/macro-reify-type.flags b/test/files/run/macro-reify-type.flags
new file mode 100644
index 0000000000..cd66464f2f
--- /dev/null
+++ b/test/files/run/macro-reify-type.flags
@@ -0,0 +1 @@
+-language:experimental.macros
\ No newline at end of file
diff --git a/test/files/run/macro-reify-type/Macros_1.scala b/test/files/run/macro-reify-type/Macros_1.scala
new file mode 100644
index 0000000000..06de05735d
--- /dev/null
+++ b/test/files/run/macro-reify-type/Macros_1.scala
@@ -0,0 +1,27 @@
+import scala.reflect.macros.Context
+import scala.reflect.runtime.{universe => ru}
+
+object StaticReflect {
+  def method[A](name: String): ru.Type = macro methodImpl[A]
+
+  def methodImpl[A: c.WeakTypeTag](c: Context)(name: c.Expr[String]): c.Expr[ru.Type] = {
+    import c.universe._
+
+    val nameName: TermName = name.tree match {
+      case Literal(Constant(str: String)) => newTermName(str)
+      case _                              => c.error(c.enclosingPosition, s"Method name not constant.") ; return reify(ru.NoType)
+    }
+    val clazz  = weakTypeOf[A]
+
+    clazz member nameName match {
+      case NoSymbol => c.error(c.enclosingPosition, s"No member called $nameName in $clazz.") ; reify(ru.NoType)
+      case member   =>
+        val mtpe  = member typeSignatureIn clazz
+        val mtag  = c.reifyType(treeBuild.mkRuntimeUniverseRef, Select(treeBuild.mkRuntimeUniverseRef, newTermName("rootMirror")), mtpe)
+        val mtree = Select(mtag, newTermName("tpe"))
+
+        c.Expr[ru.Type](mtree)
+    }
+  }
+
+}
diff --git a/test/files/run/macro-reify-type/Test_2.scala b/test/files/run/macro-reify-type/Test_2.scala
new file mode 100644
index 0000000000..9beaf98681
--- /dev/null
+++ b/test/files/run/macro-reify-type/Test_2.scala
@@ -0,0 +1,21 @@
+import StaticReflect._
+
+object Test extends App {
+  //println(method[List[Int]]("distinct"))
+  println(method[List[Int]]("map"))
+  //val $u: scala.reflect.runtime.universe.type = scala.reflect.runtime.universe;
+  //val $m: $u.Mirror = scala.reflect.runtime.universe.rootMirror;
+  //import $u._, $m._, Flag._
+  //val tpe = {
+  //  val symdef$B2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTypeName("B"), NoPosition, DEFERRED | PARAM, false);
+  //  val symdef$That2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTypeName("That"), NoPosition, DEFERRED | PARAM, false);
+  //  val symdef$f2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTermName("f"), NoPosition, PARAM, false);
+  //  val symdef$bf2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTermName("bf"), NoPosition, IMPLICIT | PARAM, false);
+  //  build.setTypeSignature(symdef$B2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor));
+  //  build.setTypeSignature(symdef$That2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor));
+  //  build.setTypeSignature(symdef$f2, TypeRef(ThisType(staticPackage("scala").asModule.moduleClass), staticClass("scala.Function1"), List(staticClass("scala.Int").asType.toTypeConstructor, TypeRef(NoPrefix, symdef$B2, List()))));
+  //  build.setTypeSignature(symdef$bf2, TypeRef(ThisType(staticPackage("scala.collection.generic").asModule.moduleClass), staticClass("scala.collection.generic.CanBuildFrom"), List(TypeRef(ThisType(staticPackage("scala.collection.immutable").asModule.moduleClass), staticClass("scala.collection.immutable.List"), List(staticClass("scala.Int").asType.toTypeConstructor)), TypeRef(NoPrefix, symdef$B2, List()), TypeRef(NoPrefix, symdef$That2, List()))));
+  //  PolyType(List(symdef$B2, symdef$That2), MethodType(List(symdef$f2), MethodType(List(symdef$bf2), TypeRef(NoPrefix, symdef$That2, List()))))
+  //}
+  //println(tpe)
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_nosymbol.check b/test/files/run/showraw_nosymbol.check
new file mode 100644
index 0000000000..c54fe74717
--- /dev/null
+++ b/test/files/run/showraw_nosymbol.check
@@ -0,0 +1 @@
+NoSymbol
diff --git a/test/files/run/showraw_nosymbol.scala b/test/files/run/showraw_nosymbol.scala
new file mode 100644
index 0000000000..fbdc1591c9
--- /dev/null
+++ b/test/files/run/showraw_nosymbol.scala
@@ -0,0 +1,5 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  println(showRaw(NoSymbol))
+}
\ No newline at end of file
diff --git a/test/files/run/t576.scala b/test/files/run/t576.scala
index dc09d8dc98..756a241572 100644
--- a/test/files/run/t576.scala
+++ b/test/files/run/t576.scala
@@ -12,7 +12,7 @@ object Dingus {
 object Test {
   val x1 = new A
   val x2 = new A
-  
+
   val x3 = new { self =>
     override def equals(other : Any) = other match {
       case that: self.type    => true
@@ -20,7 +20,7 @@ object Test {
     }
   }
   val x4 = new { self =>
-    def f(x: Any) = x match {
+    def f(x: Any): Int = x match {
       case _: x1.type     => 1
       case _: x2.type     => 2
       case _: x3.type     => 3
@@ -35,11 +35,11 @@ object Test {
     assert(x1 != x2)
     assert(x1 != ())
     assert(x2 != x1)
-    
+
     assert(x3 == x3)
     assert(x3 != x2)
     assert(x2 != x3)
-    
+
     List(x1, x2, x3, x4, Dingus) map x4.f foreach println
   }
-}
\ No newline at end of file
+}
diff --git a/test/files/run/t6380.check b/test/files/run/t6380.check
new file mode 100644
index 0000000000..912525ed66
--- /dev/null
+++ b/test/files/run/t6380.check
@@ -0,0 +1,7 @@
+List(class java.lang.Exception)
+List(class java.lang.Throwable)
+List(class java.lang.RuntimeException)
+List(class java.lang.IllegalArgumentException, class java.util.NoSuchElementException)
+List(class java.lang.IndexOutOfBoundsException, class java.lang.IndexOutOfBoundsException)
+List(class java.lang.IllegalStateException, class java.lang.IllegalStateException)
+List(class java.lang.NullPointerException, class java.lang.NullPointerException)
diff --git a/test/files/run/t6380.scala b/test/files/run/t6380.scala
new file mode 100644
index 0000000000..0e264d9175
--- /dev/null
+++ b/test/files/run/t6380.scala
@@ -0,0 +1,20 @@
+object Test extends App {
+  classOf[Foo].getDeclaredMethods().sortBy(_.getName).map(_.getExceptionTypes.sortBy(_.getName).toList).toList.foreach(println)
+}
+
+class Foo {
+  @throws[Exception]
+  def bar1 = ???
+  @throws[Throwable]("always")
+  def bar2 = ???
+  @throws(classOf[RuntimeException])
+  def bar3 = ???
+  @throws[IllegalArgumentException] @throws[NoSuchElementException]
+  def bar4 = ???
+  @throws(classOf[IndexOutOfBoundsException]) @throws(classOf[IndexOutOfBoundsException])
+  def bar5 = ???
+  @throws[IllegalStateException]("Cause") @throws[IllegalStateException]
+  def bar6 = ???
+  @throws[NullPointerException]("Cause A") @throws[NullPointerException]("Cause B")
+  def bar7 = ???
+}
\ No newline at end of file
diff --git a/test/pending/pos/exhaust_2.scala b/test/pending/pos/exhaust_2.scala
new file mode 100644
index 0000000000..4f4e47c43b
--- /dev/null
+++ b/test/pending/pos/exhaust_2.scala
@@ -0,0 +1,54 @@
+object ExhaustivityWarnBugReportMinimal {
+  //sealed is needed for the warning
+  sealed trait FoundNode[T]/*presence of parameters is irrelevant*/
+  // This also causes a warning:
+  // sealed abstract class FoundNode[T]/*presence of parameters is irrelevant*/
+  case class FoundFilter[T](/*presence of parameters is irrelevant*/) extends FoundNode[T]
+  case class FoundTypeCase[T](/*presence of parameters is irrelevant*/) extends FoundNode[T]
+  val f: Some[_] = ???
+  f match {
+    case x: Some[t] => //no warning
+  }
+  //With these variants, no warnings:
+  //val v: (Some[Int], FoundNode[_]) = (???, ???)
+  //val v: (Some[AnyRef], FoundNode[_]) = (???, ???)
+  //val v: (Some[String], FoundNode[_]) = (???, ???)
+
+  val v: (Some[_], FoundNode[_]) = (???, ???)
+  //Warning here:
+  v match {
+    case (x: Some[t], _: FoundNode[_]) =>
+  }
+  v match {
+    case (x: Some[t], _) =>
+  }
+
+  v match {
+    case (x: Some[_], _) =>
+  }
+  case class Foo[T]()
+
+  val vp: (Foo[_], FoundNode[_]) = (???, ???)
+  vp match {
+    case (x: Foo[_], _) =>
+  }
+
+  //No warning here:
+  v match {
+    case (Some(y), _) =>
+  }
+
+  v match {
+    case (x, _) =>
+  }
+
+  val v2: (Some[_], Int) = (???, ???)
+  v2 match {
+    case (x: Some[t], _) =>
+  }
+
+  val v3: (Option[_], FoundNode[_]) = (???, ???)
+  v match {
+    case (x: Option[_], _) =>
+  }
+}