Implement negation of implicit searches

Previously, ambiguous implicits were used to make a local implicit
search fail so that another alternative could be considered globally.
This is no longer possible because implicit search now propagates.

This commit makes similar functionality available by implementing
a special Not class. It also re-establishes the old behavior under
-language:Scala2, issuing a migration warning.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -584,6 +584,12 @@ class Definitions {
 
     def Eq_eqAny(implicit ctx: Context) = EqModule.requiredMethod(nme.eqAny)
 
+  lazy val NotType = ctx.requiredClassRef("scala.implicits.Not")
+  def NotClass(implicit ctx: Context) = NotType.symbol.asClass
+  def NotModule(implicit ctx: Context) = NotClass.companionModule
+
+    def Not_value(implicit ctx: Context) = NotModule.requiredMethod(nme.value)
+
   lazy val XMLTopScopeModuleRef = ctx.requiredModuleRef("scala.xml.TopScope")
 
   // Annotation base classes

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -262,6 +262,7 @@ object Implicits {
       case _: SearchSuccess => this
       case fail: SearchFailure => other(fail)
     }
+    def isSuccess = isInstanceOf[SearchSuccess]
   }
 
   /** A successful search
@@ -503,8 +504,7 @@ trait Implicits { self: Typer =>
     && from.isValueType
     && (  from.isValueSubType(to)
        || inferView(dummyTreeOfType(from), to)
-            (ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState())
-            .isInstanceOf[SearchSuccess]
+            (ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState()).isSuccess
           // TODO: investigate why we can't TyperState#test here
        )
     )
@@ -583,7 +583,7 @@ trait Implicits { self: Typer =>
     }
 
     def hasEq(tp: Type): Boolean =
-      inferImplicit(defn.EqType.appliedTo(tp, tp), EmptyTree, pos).isInstanceOf[SearchSuccess]
+      inferImplicit(defn.EqType.appliedTo(tp, tp), EmptyTree, pos).isSuccess
 
     def validEqAnyArgs(tp1: Type, tp2: Type)(implicit ctx: Context) = {
       List(tp1, tp2).foreach(fullyDefinedType(_, "eqAny argument", pos))
@@ -787,6 +787,8 @@ trait Implicits { self: Typer =>
     /** The expected type where parameters and uninstantiated typevars are replaced by wildcard types */
     val wildProto = implicitProto(pt, wildApprox(_, null, Set.empty))
 
+    val isNot = wildProto.classSymbol == defn.NotClass
+
     /** Search a list of eligible implicit references */
     def searchImplicits(eligible: List[Candidate], contextual: Boolean): SearchResult = {
       val constr = ctx.typerState.constraint
@@ -896,10 +898,23 @@ trait Implicits { self: Typer =>
         case cand :: pending1 =>
           tryImplicit(cand) match {
             case fail: SearchFailure =>
-              if (fail.isAmbiguous) healAmbiguous(pending1, fail)
-              else rank(pending1, found, fail :: rfailures)
+              if (isNot)
+                SearchSuccess(ref(defn.Not_value), defn.Not_value.termRef, 0)(ctx.typerState)
+              else if (fail.isAmbiguous)
+                if (ctx.scala2Mode) {
+                  val result = rank(pending1, found, NoMatchingImplicitsFailure :: rfailures)
+                  if (result.isSuccess)
+                    warnAmbiguousNegation(fail.reason.asInstanceOf[AmbiguousImplicits])
+                  result
+                }
+                else
+                  healAmbiguous(pending1, fail)
+              else
+                rank(pending1, found, fail :: rfailures)
             case best: SearchSuccess =>
-              if (ctx.mode.is(Mode.ImplicitExploration) || isCoherent)
+              if (isNot)
+                NoMatchingImplicitsFailure
+              else if (ctx.mode.is(Mode.ImplicitExploration) || isCoherent)
                 best
               else disambiguate(found, best) match {
                 case retained: SearchSuccess =>
@@ -917,6 +932,15 @@ trait Implicits { self: Typer =>
           else found.recoverWith(_ => rfailures.reverse.maxBy(_.tree.treeSize))
       }
 
+      def warnAmbiguousNegation(ambi: AmbiguousImplicits) =
+        ctx.migrationWarning(
+          i"""Ambiguous implicits ${ambi.alt1.ref.symbol.showLocated} and ${ambi.alt2.ref.symbol.showLocated}
+             |seem to be used to implement a local failure in order to negate an implicit search.
+             |According to the new implicit resolution rules this is no longer possible;
+             |the search will fail with a global ambiguity error instead.
+             |
+             |Consider using the scala.implicits.Not class to implement similar functionality.""", pos)
+
       /** A relation that imfluences the order in which implicits are tried.
        *  We prefer (in order of importance)
        *   1. more deeply nested definitions

library/src/scala/implicits/Not.scala

@@ -0,0 +1,9 @@
+package scala.implicits
+
+final class Not[+T] private ()
+
+object Not {
+  def value: Not[Nothing] = new Not[Nothing]()
+  implicit def amb1[T](implicit ev: T): Not[T] = ???
+  implicit def amb2[T](implicit ev: T): Not[T] = ???
+}

tests/pos-scala2/i3396.scala

@@ -0,0 +1,34 @@
+object Test {
+
+  trait Tagged[A]
+
+  // Negation Tagged: NotTagged[A] is available only if there are no Tagged[A] in scope.
+  trait NotTagged[A]
+  trait NotTaggedLowPrio {
+    implicit def notTaggedInstance[A]: NotTagged[A] = null
+  }
+  object NotTagged extends NotTaggedLowPrio {
+    implicit def notTaggedAmbiguity1[A](implicit ev: Tagged[A]): NotTagged[A] = null
+    implicit def notTaggedAmbiguity2[A](implicit ev: Tagged[A]): NotTagged[A] = null
+  }
+
+
+  case class Foo[A](value: Boolean)
+  trait FooLowPrio {
+    implicit def fooDefault[A]: Foo[A] = Foo(true)
+  }
+  object Foo extends FooLowPrio {
+    implicit def fooNotTagged[A](implicit ev: NotTagged[A]): Foo[A] = Foo(false)
+  }
+
+
+  def main(args: Array[String]): Unit = {
+    implicit val taggedInt: Tagged[Int] = null
+
+    assert(implicitly[Foo[Int]].value) // fooDefault
+
+    assert(!implicitly[Foo[String]].value) // fooNotTagged
+
+    println(1)
+  }
+}

tests/run/i3396.scala

@@ -0,0 +1,25 @@
+import implicits.Not
+
+object Test {
+
+  trait Tagged[A]
+
+  case class Foo[A](value: Boolean)
+  trait FooLowPrio {
+    implicit def fooDefault[A]: Foo[A] = Foo(true)
+  }
+  object Foo extends FooLowPrio {
+    implicit def fooNotTagged[A](implicit ev: Not[Tagged[A]]): Foo[A] = Foo(false)
+  }
+
+
+  def main(args: Array[String]): Unit = {
+    implicit val taggedInt: Tagged[Int] = null
+
+    assert(implicitly[Foo[Int]].value) // fooDefault
+
+    assert(!implicitly[Foo[String]].value) // fooNotTagged
+
+    println(1)
+  }
+}