Avoid double-feature reporting

The extended explanation attached to the first feature
warning would fool the reporter if the feature is reported
again at the same position.

Use a conventional leading `"----"` to demarcate the
explanation, and use only the prefix to see if the error
has already been issued at a position.

Author: som-snytt

src/compiler/scala/tools/nsc/Reporting.scala

@@ -97,6 +97,7 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w
       val explain = (
         if (reportedFeature contains featureTrait) "" else
         s"""|
+            |----
             |This can be achieved by adding the import clause 'import $fqname'
             |or by setting the compiler option -language:$featureName.
             |See the Scaladoc for value $fqname for a discussion

src/compiler/scala/tools/nsc/reporters/DisplayReporter.scala

@@ -46,7 +46,7 @@ trait PrintReporter extends InternalReporter {
 
   /** Format a message and emit it. */
   def display(pos: Position, msg: String, severity: Severity): Unit = {
-    val text = formatMessage(pos, s"${clabel(severity)}${msg}", shortname)
+    val text = formatMessage(pos, s"${clabel(severity)}${DisplayReporter.explanation(msg)}", shortname)
     severity match {
       case INFO => echoMessage(text)
       case _    => printMessage(text)
@@ -97,6 +97,21 @@ object DisplayReporter {
     writer: PrintWriter     = new PrintWriter(Console.err, true),
     echoWriter: PrintWriter = new PrintWriter(Console.out, true)
   ) = new DisplayReporter(settings, reader, writer, echoWriter)
+
+  /** Take the message with its explanation, if it has one. */
+  def explanation(msg: String): String = splitting(msg, explaining = true)
+
+  /** Take the message without its explanation, if it has one. */
+  def stripExplanation(msg: String): String = splitting(msg, explaining = false)
+
+  /** Split a message into a prefix and an optional explanation that follows a line starting with `"----"`. */
+  private def splitting(msg: String, explaining: Boolean): String =
+    if (msg.indexOf("\n----") > 0) {
+      val (err, exp) = msg.lines.span(!_.startsWith("----"))
+      if (explaining) (err ++ exp.drop(1)).mkString("\n") else err.mkString("\n")
+    } else {
+      msg
+    }
 }
 
 /** A reporter that filters by position and forwards for display */

src/compiler/scala/tools/nsc/reporters/PositionFilter.scala

@@ -46,16 +46,18 @@ trait PositionFiltering extends InternalReporter with Filtering {
         case ERROR                    => true  // already error at position
         case highest
           if highest.id > severity.id => true  // already message higher than present severity
-        case `severity`               => messages(fpos) contains msg // already issued this exact message
+        case `severity`               => matchAt(fpos, msg) // already issued this (in)exact message
         case _                        => false // good to go
       }
 
       suppress || {
         positions(fpos) = severity
-        messages(fpos) ::= msg
+        messages(fpos) ::= DisplayReporter.stripExplanation(msg)  // ignore explanatory suffix for suppressing duplicates
         false
       }
     }
+  // was a prefix of the msg already reported at this position for purposes of suppressing repetition?
+  private def matchAt(pos: Position, msg: String): Boolean = messages(pos).exists(msg.startsWith(_))
 }
 
 /** This reporter implements filtering by severity and position.

test/files/neg/double-feature.check

@@ -0,0 +1,19 @@
+double-feature.scala:4: warning: implicit conversion method f should be enabled
+by making the implicit value scala.language.implicitConversions visible.
+This can be achieved by adding the import clause 'import scala.language.implicitConversions'
+or by setting the compiler option -language:implicitConversions.
+See the Scaladoc for value scala.language.implicitConversions for a discussion
+why the feature should be explicitly enabled.
+  implicit def f(t: T): String = "I am the tee"
+               ^
+double-feature.scala:6: warning: postfix operator + should be enabled
+by making the implicit value scala.language.postfixOps visible.
+This can be achieved by adding the import clause 'import scala.language.postfixOps'
+or by setting the compiler option -language:postfixOps.
+See the Scaladoc for value scala.language.postfixOps for a discussion
+why the feature should be explicitly enabled.
+  val g: Int => Int = 1 +
+                        ^
+error: No warnings can be incurred under -Xfatal-warnings.
+two warnings found
+one error found

test/files/neg/double-feature.flags

@@ -0,0 +1 @@
+-feature -Xfatal-warnings

test/files/neg/double-feature.scala

@@ -0,0 +1,11 @@
+
+object Test {
+  trait T
+  implicit def f(t: T): String = "I am the tee"
+  //val n = "hello, world" length
+  val g: Int => Int = 1 +
+  def main(args: Array[String]): Unit = println {(
+    null.asInstanceOf[T] : String,
+    List(1).map(g),
+  )}
+}