Fix some tests

Author: therealcisse

docs/blog/_posts/2017-12-01-fifth-dotty-milestone-release.md

@@ -52,8 +52,8 @@ 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` which
-implements negation directly. For any query type `Q`: `Not[Q]` succeeds if and only if the
+techniques no longer work. But there is now a new special type `scala.util.NotGiven` which
+implements negation directly. For any query type `Q`: `NotGiven[Q]` succeeds if and only if the
 implicit search for `Q` fails.
 
 ### Dependent function types [#3464](https://github.com/lampepfl/dotty/pull/3464)

tests/neg-macros/i9972/Macro_1.scala

@@ -1,7 +1,7 @@
 package notmacro
 
-import scala.util.Not
+import scala.util.NotGiven
 
 object Main extends App {
-  summon[Not[T[Int]]] // error
+  summon[NotGiven[T[Int]]] // error
 }

tests/neg-macros/i9972b/Macro_1.scala

@@ -1,3 +1,3 @@
 
 def test: Unit =
-  summon[scala.util.Not[T[Int]]] // error
+  summon[scala.util.NotGiven[T[Int]]] // error

tests/neg/i5234a.scala

@@ -1,10 +1,10 @@
 object Test {
-  import scala.util.Not
+  import scala.util.NotGiven
 
   class Foo
   class Bar
   implicit def foo: Foo = ???
   implicitly[Foo]
-  implicitly[Not[Foo]] // error
-  implicitly[Not[Bar]]
+  implicitly[NotGiven[Foo]] // error
+  implicitly[NotGiven[Bar]]
 }

tests/neg/i5234b.scala

@@ -1,30 +1,30 @@
-final class Not2[T] private ()
+final class NotGiven2[T] private ()
 
-trait LowPriorityNot2 {
+trait LowPriorityNotGiven2 {
 
   /** A fallback method used to emulate negation in Scala 2 */
-  implicit def default[T]: Not2[T] = Not2.value.asInstanceOf[Not2[T]]
+  implicit def default[T]: NotGiven2[T] = NotGiven2.value.asInstanceOf[NotGiven2[T]]
 }
-object Not2 extends LowPriorityNot2 {
+object NotGiven2 extends LowPriorityNotGiven2 {
 
-  /** A value of type `Not` to signal a successful search for `Not[C]` (i.e. a failing
+  /** A value of type `NotGiven` to signal a successful search for `NotGiven[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: Not2[Nothing] = new Not2[Nothing]()
+  def value: NotGiven2[Nothing] = new NotGiven2[Nothing]()
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
-  implicit def amb1[T](implicit ev: T): Not2[T] = ???
+  implicit def amb1[T](implicit ev: T): NotGiven2[T] = ???
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
-  implicit def amb2[T](implicit ev: T): Not2[T] = ???
+  implicit def amb2[T](implicit ev: T): NotGiven2[T] = ???
 }
 
 object Test {
   class Foo
   class Bar
   implicit def foo: Foo = ???
   implicitly[Foo]
-  implicitly[Not2[Foo]] // error
-  implicitly[Not2[Bar]]
+  implicitly[NotGiven2[Foo]] // error
+  implicitly[NotGiven2[Bar]]
 }

tests/neg/i5234c.scala

@@ -1,9 +1,9 @@
 object Test {
-  import scala.util.Not
+  import scala.util.NotGiven
 
   class Foo
   implicit def foo: Foo = ???
 
-  def foo[T](implicit ev: Not[T]) = ???
+  def foo[T](implicit ev: NotGiven[T]) = ???
   foo[Foo] // error
 }

tests/run/i3396.scala

@@ -1,4 +1,4 @@
-import scala.util.Not
+import scala.util.NotGiven
 
 object Test {
 
@@ -9,7 +9,7 @@ object Test {
     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)
+    implicit def fooNotTagged[A](implicit ev: NotGiven[Tagged[A]]): Foo[A] = Foo(false)
   }