Merge pull request #1012 from paulp/topic/unchecked-goes-hollywood

Promote unchecked warnings into being emitted by default.

7 files changed, 38 insertions, 38 deletions

diff --git a/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala
index 0991577829..ee26bb2817 100644
--- a/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala
@@ -43,7 +43,7 @@ trait StandardScalaSettings {
   val target =          ChoiceSetting ("-target", "target", "Target platform for object files. All JVM 1.5 targets are deprecated.",
                                        List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7", "msil"),
                                        "jvm-1.6")
-  val unchecked =      BooleanSetting ("-unchecked", "Enable detailed unchecked (erasure) warnings.")
+  val unchecked =      BooleanSetting ("-unchecked", "Enable additional warnings where generated code depends on assumptions.")
   val uniqid =         BooleanSetting ("-uniqid", "Uniquely tag all identifiers in debugging output.")
   val usejavacp =      BooleanSetting ("-usejavacp", "Utilize the java.class.path in classpath resolution.")
   val verbose =        BooleanSetting ("-verbose", "Output messages about what the compiler is doing.")
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index 1f7c34b8ad..f0979978b0 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -416,7 +416,7 @@ abstract class ExplicitOuter extends InfoTransform
 
       val (checkExhaustive, requireSwitch) = nselector match {
         case Typed(nselector1, tpt) =>
-          val unchecked = treeInfo.isUncheckedAnnotation(tpt.tpe)
+          val unchecked = tpt.tpe hasAnnotation UncheckedClass
           if (unchecked)
             nselector = nselector1
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index e096b75d6d..3be4a46a79 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -1366,14 +1366,16 @@ trait Infer {
             else if (param.isContravariant) >:>
             else =:=
           )
-          val TypeRef(_, sym, args) = arg
-
-          (    isLocalBinding(sym)
-            || arg.typeSymbol.isTypeParameterOrSkolem
-            || (sym.name == tpnme.WILDCARD) // avoid spurious warnings on HK types
-            || check(arg, param.tpe, conforms)
-            || warn("non-variable type argument " + arg)
-          )
+          (arg hasAnnotation UncheckedClass) || {
+            val TypeRef(_, sym, args) = arg.withoutAnnotations
+
+            (    isLocalBinding(sym)
+              || arg.typeSymbol.isTypeParameterOrSkolem
+              || (sym.name == tpnme.WILDCARD) // avoid spurious warnings on HK types
+              || check(arg, param.tpe, conforms)
+              || warn("non-variable type argument " + arg)
+            )
+          }
         }
 
         // Checking if pt (the expected type of the pattern, and the type
@@ -1404,8 +1406,11 @@ trait Infer {
         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.uncheckedWarning(tree.pos, s"$m in type $where is unchecked since it is eliminated by erasure"))
+            context.unit.warning(tree.pos, s"$m in type $where is unchecked since it is eliminated by erasure"))
       }
     }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index a4457936c8..a8286c9f19 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -1228,7 +1228,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
           if (settings.XnoPatmatAnalysis.value) (true, false)
           else scrut match {
             case Typed(_, tpt) =>
-              (treeInfo.isUncheckedAnnotation(tpt.tpe),
+              (tpt.tpe hasAnnotation UncheckedClass,
                // matches with two or fewer cases need not apply for switchiness (if-then-else will do)
                treeInfo.isSwitchAnnotation(tpt.tpe) && casesNoSubstOnly.lengthCompare(2) > 0)
             case _ =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 4673e58b64..5403669050 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3220,7 +3220,7 @@ trait Typers extends Modes with Adaptations with Tags {
       // we don't create a new Context for a Match, so find the CaseDef, then go out one level and navigate back to the match that has this case
       // val thisCase = context.nextEnclosing(_.tree.isInstanceOf[CaseDef])
       // val unchecked = thisCase.outer.tree.collect{case Match(selector, cases) if cases contains thisCase => selector} match {
-      //   case List(Typed(_, tpt)) if treeInfo.isUncheckedAnnotation(tpt.tpe) => true
+      //   case List(Typed(_, tpt)) if tpt.tpe hasAnnotation UncheckedClass => true
       //   case t => println("outer tree: "+ (t, thisCase, thisCase.outer.tree)); false
       // }
       // println("wrapClassTagUnapply"+ (!isPastTyper && infer.containsUnchecked(pt), pt, uncheckedPattern))
diff --git a/src/library/scala/unchecked.scala b/src/library/scala/unchecked.scala
index 10d34312cf..5b05792d97 100644
--- a/src/library/scala/unchecked.scala
+++ b/src/library/scala/unchecked.scala
@@ -6,32 +6,30 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala
 
-/** An annotation that gets applied to a selector in a match expression.
- *  If it is present, exhaustiveness warnings for that expression will be
- *  suppressed.
- *  For example, compiling the code:
+/** An annotation to designate that the annotated entity
+ *  should not be considered for additional compiler checks.
+ *  Specific applications include annotating the subject of
+ *  a match expression to suppress exhaustiveness warnings, and
+ *  annotating a type argument in a match case to suppress
+ *  unchecked warnings.
+ *
+ *  Such suppression should be used with caution, without which
+ *  one may encounter [[scala.MatchError]] or [[java.lang.ClassCastException]]
+ *  at runtime.  In most cases one can and should address the
+ *  warning instead of suppressing it.
+ *
  *  {{{
- *    object test extends App {
- *      def f(x: Option[Int]) = x match {
- *        case Some(y) => y
- *      }
- *      f(None)
+ *    object Test extends App {
+ *      // This would normally warn "match is not exhaustive"
+ *      // because `None` is not covered.
+ *      def f(x: Option[String]) = (x: @unchecked) match { case Some(y) => y }
+ *      // This would normally warn "type pattern is unchecked"
+ *      // but here will blindly cast the head element to String.
+ *      def g(xs: Any) = xs match { case x: List[String @unchecked] => x.head }
  *    }
- *  }}}
- *  will display the following warning:
- *  {{{
- *    test.scala:2: warning: does not cover case {object None}
- *      def f(x: Option[int]) = x match {
- *                              ^
- *    one warning found
- *  }}}
- *  The above message may be suppressed by substituting the expression `x`
- *  with `(x: @unchecked)`. Then the modified code will compile silently,
- *  but, in any case, a [[scala.MatchError]] will be raised at runtime.
+ * }}}
  *
  *  @since 2.4
  */
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 17a01e1af9..f6b004f985 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -326,9 +326,6 @@ abstract class TreeInfo {
     case _ => false
   }
 
-  /** a Match(Typed(_, tpt), _) is unchecked if isUncheckedAnnotation(tpt.tpe) */
-  def isUncheckedAnnotation(tpe: Type) = tpe hasAnnotation definitions.UncheckedClass
-
   /** a Match(Typed(_, tpt), _) must be translated into a switch if isSwitchAnnotation(tpt.tpe) */
   def isSwitchAnnotation(tpe: Type) = tpe hasAnnotation definitions.SwitchClass