Rename scala.implicits.Not to scala.util.Not

Having a package just for this type seems weird, especially since we no
longer call them "implicits". After discussion it was deemed not useful
enough to go in the root scala package, so `scala.util` it is.

Author: smarter

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

@@ -738,7 +738,7 @@ class Definitions {
     @tu lazy val TypeBox_CAP: TypeSymbol = TypeBoxClass.requiredType(tpnme.CAP)
 
   @tu lazy val MatchCaseClass: ClassSymbol = requiredClass("scala.internal.MatchCase")
-  @tu lazy val NotClass: ClassSymbol = requiredClass("scala.implicits.Not")
+  @tu lazy val NotClass: ClassSymbol = requiredClass("scala.util.Not")
     @tu lazy val Not_value: Symbol = NotClass.companionModule.requiredMethod(nme.value)
 
   @tu lazy val ValueOfClass: ClassSymbol = requiredClass("scala.ValueOf")

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

@@ -1234,7 +1234,7 @@ trait Implicits:
              |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.""",
+             |Consider using the scala.util.Not class to implement similar functionality.""",
              ctx.source.atSpan(span))
 
       /** A relation that influences the order in which implicits are tried.

compiler/test-resources/repl/importFromObj

@@ -11,11 +11,11 @@ scala> buf += xs
   |        Required: Int
 scala> buf ++= xs
 val res0: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
-scala> import util.foo
-1 | import util.foo
-  |             ^^^
-  |             value foo is not a member of util
-scala> import util.foo.bar
-1 | import util.foo.bar
-  |        ^^^^^^^^
-  |        value foo is not a member of util
+scala> import util.foobar
+1 | import util.foobar
+  |             ^^^^^^
+  |             value foobar is not a member of util
+scala> import util.foobar.bar
+1 | import util.foobar.bar
+  |        ^^^^^^^^^^^
+  |        value foobar is not a member of util

docs/docs/reference/changed-features/implicit-resolution.md

@@ -107,7 +107,7 @@ which means that the alternative `c` would be chosen as solution!
 Scala 2's somewhat puzzling behavior with respect to ambiguity has been exploited to implement
 the analogue of a "negated" search in implicit resolution, where a query `Q1` fails if some
 other query `Q2` succeeds and `Q1` succeeds if `Q2` fails. With the new cleaned up behavior
-these techniques no longer work. But there is now a new special type `scala.implicits.Not`
+these techniques no longer work. But there is now a new special type `scala.util.Not`
 which implements negation directly. For any query type `Q`: `Not[Q]` succeeds if and only if
 the implicit search for `Q` fails.
 

library/src-bootstrapped/scala/implicits/package.scala

@@ -0,0 +1,6 @@
+package scala
+
+package object implicits {
+  @deprecated("scala.implicits.Not has been renamed scala.util.Not", "0.27.0")
+  type Not[A] = scala.util.Not[A]
+}

library/src-bootstrapped/scala/util/Not.scala

@@ -0,0 +1,45 @@
+package scala.util
+
+/** A special class used to implement negation in implicit search.
+ *
+ *  Consider the problem of using implicit `i1` for a query type `D` if an implicit
+ *  for some other class `C` is available, and using an implicit `i2` if no implicit
+ *  value of type `C` is available. If we do not want to prioritize `i1` and `i2` by
+ *  putting them in different traits we can instead define the following:
+ *
+ *     given i1: D(using ev: C) = ...
+ *     given i2: D(using ev: Not[C]) = ...
+ *
+ *  `Not` is treated specially in implicit search, similar to the way logical negation
+ *  is treated in Prolog: The implicit search for `Not[C]` succeeds if and only if the implicit
+ *  search for `C` fails.
+ *
+ *  In Scala 2 this form of negation can be simulated by setting up a conditional
+ *  ambiguous implicit and an unconditional fallback, the way it is done with the
+ *  `default`, `amb1` and `amb2` methods below. Due to the way these two methods are
+ *  defined, `Not` is also usable from Scala 2.
+ *
+ *  In Dotty, ambiguity is a global error, and therefore cannot be used to implement negation.
+ *  Instead, `Not` is treated natively in implicit search.
+ */
+final class Not[+T] private ()
+
+trait LowPriorityNot {
+
+  /** A fallback method used to emulate negation in Scala 2 */
+  given default[T] as Not[T] = Not.value
+}
+object Not extends LowPriorityNot {
+
+  /** A value of type `Not` to signal a successful search for `Not[C]` (i.e. a failing
+   *  search for `C`). A reference to this value will be explicitly constructed by Dotty's
+   *  implicit search algorithm
+   */
+  def value: Not[Nothing] = new Not[Nothing]()
+
+  /** One of two ambiguous methods used to emulate negation in Scala 2 */
+  given amb1[T](using ev: T) as Not[T] = ???
+
+  /** One of two ambiguous methods used to emulate negation in Scala 2 */
+  given amb2[T](using ev: T) as Not[T] = ???
+}