Rename implicit match to implied match

biboudis · biboudis · commit 1b9d69fc2a0f · 2019-06-05T19:00:54.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -198,6 +198,8 @@ object Parsers {
       !in.isSoftModifierInModifierPosition
 
     def isExprIntro: Boolean =
+      // if (in.token == IMPLIED) in.lookaheadIn(BitSet(MATCH))
+      // else
       canStartExpressionTokens.contains(in.token) &&
       !in.isSoftModifierInModifierPosition
 
@@ -1265,7 +1267,7 @@ object Parsers {
      *                      |  SimpleExpr1 ArgumentExprs `=' Expr
      *                      |  Expr2
      *                      |  [‘inline’] Expr2 `match' `{' CaseClauses `}'
-     *                      |  `implicit' `match' `{' ImplicitCaseClauses `}'
+     *                      |  `implied' `match' `{' ImplicitCaseClauses `}'
      *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
      *  Binding           ::=  (id | `_') [`:' Type]
      *  Expr2             ::=  PostfixExpr [Ascription]
@@ -1280,8 +1282,8 @@ object Parsers {
     def expr(location: Location.Value): Tree = {
       val start = in.offset
       if (closureMods.contains(in.token)) {
-        val imods = modifiers(closureMods)
-        if (in.token == MATCH) implicitMatch(start, imods)
+        val imods = modifiers(closureMods + IMPLIED)
+        if (in.token == MATCH) impliedMatch(start, imods)
         else implicitClosure(start, location, imods)
       } else {
         val saved = placeholderParams
@@ -1457,13 +1459,13 @@ object Parsers {
 
     /**    `match' { ImplicitCaseClauses }
      */
-    def implicitMatch(start: Int, imods: Modifiers) = {
+    def impliedMatch(start: Int, imods: Modifiers) = {
       def markFirstIllegal(mods: List[Mod]) = mods match {
-        case mod :: _ => syntaxError(em"illegal modifier for implicit match", mod.span)
+        case mod :: _ => syntaxError(em"illegal modifier for implied match", mod.span)
         case _ =>
       }
       imods.mods match {
-        case Mod.Implicit() :: mods => markFirstIllegal(mods)
+        case Mod.Instance() :: mods => markFirstIllegal(mods)
         case mods => markFirstIllegal(mods)
       }
       val result @ Match(t, cases) =
@@ -1474,7 +1476,7 @@ object Parsers {
           case pat => isVarPattern(pat)
         }
         if (!isImplicitPattern(pat))
-          syntaxError(em"not a legal pattern for an implicit match", pat.span)
+          syntaxError(em"not a legal pattern for an implied match", pat.span)
       }
       result
     }
@@ -1999,6 +2001,7 @@ object Parsers {
       case ABSTRACT    => Mod.Abstract()
       case FINAL       => Mod.Final()
       case IMPLICIT    => Mod.Implicit()
+      case IMPLIED     => Mod.Instance()
       case GIVEN       => Mod.Given()
       case ERASED      => Mod.Erased()
       case LAZY        => Mod.Lazy()
@@ -3084,11 +3087,11 @@ object Parsers {
         else if (isDefIntro(localModifierTokens))
           if (closureMods.contains(in.token)) {
             val start = in.offset
-            var imods = modifiers(closureMods)
+            var imods = modifiers(closureMods + IMPLIED)
             if (isBindingIntro)
               stats += implicitClosure(start, Location.InBlock, imods)
             else if (in.token == MATCH)
-              stats += implicitMatch(start, imods)
+              stats += impliedMatch(start, imods)
             else
               stats +++= localDef(start, imods)
           } else {
diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -216,7 +216,7 @@ object Tokens extends TokensCommon {
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
 
   final val canStartExpressionTokens: TokenSet = atomicExprTokens | BitSet(
-    LBRACE, LPAREN, QUOTE, IF, DO, WHILE, FOR, NEW, TRY, THROW)
+    LBRACE, LPAREN, QUOTE, IF, DO, WHILE, FOR, NEW, TRY, THROW, IMPLIED)
 
   final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -111,7 +111,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
           .appliedTo(Literal(Constant(s"native method stub"))))
 
     }
-    else ddef
+      ddef
   }
 
   override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -720,9 +720,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     /** Reduce an inline match
      *   @param     mtch          the match tree
      *   @param     scrutinee     the scrutinee expression, assumed to be pure, or
-     *                            EmptyTree for an implicit match
+     *                            EmptyTree for an implied match
      *   @param     scrutType     its fully defined type, or
-     *                            ImplicitScrutineeTypeRef for an implicit match
+     *                            ImplicitScrutineeTypeRef for an implied match
      *   @param     typer         The current inline typer
      *   @return    optionally, if match can be reduced to a matching case: A pair of
      *              bindings for all pattern-bound variables and the RHS of the case.
@@ -1036,7 +1036,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
             def patStr(cdef: untpd.CaseDef) = i"case ${cdef.pat}${guardStr(cdef.guard)}"
             val msg =
               if (tree.selector.isEmpty)
-                em"""cannot reduce implicit match with
+                em"""cannot reduce implied match with
                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
               else
                 em"""cannot reduce inline match with
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1021,7 +1021,7 @@ class Typer extends Namer
     tree.selector match {
       case EmptyTree =>
         if (tree.isInline) {
-          checkInInlineContext("implicit match", tree.posd)
+          checkInInlineContext("implied match", tree.posd)
           val cases1 = tree.cases.mapconserve {
             case cdef @ CaseDef(pat @ Typed(Ident(nme.WILDCARD), _), _, _) =>
               // case _ : T  -->  case evidence$n : T
diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala
@@ -209,7 +209,7 @@ trait Core {
         /** Tree representing a pattern match `x match  { ... }` in the source code */
         type Match = kernel.Match
 
-        /** Tree representing a pattern match `implicit match { ... }` in the source code */
+        /** Tree representing a pattern match `implied match { ... }` in the source code */
         type ImplicitMatch = kernel.ImplicitMatch
 
         /** Tree representing a try catch `try x catch { ... } finally { ... }` in the source code */
diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala
@@ -475,7 +475,7 @@ trait Kernel {
   def Match_apply(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match
   def Match_copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match
 
-  /** Tree representing a pattern match `implicit match  { ... }` in the source code */
+  /** Tree representing a pattern match `implied match  { ... }` in the source code */
   type ImplicitMatch <: Term
 
   def matchImplicitMatch(tree: Tree)(implicit ctx: Context): Option[ImplicitMatch]
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
@@ -910,7 +910,7 @@ trait Printers
           inBlock(printCases(cases, lineBreak()))
 
         case ImplicitMatch(cases) =>
-          this += highlightKeyword("implicit match", color)
+          this += highlightKeyword("implied match", color)
           inBlock(printCases(cases, lineBreak()))
 
         case Try(body, cases, finallyOpt) =>
diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala
@@ -594,14 +594,14 @@ trait TreeOps extends Core {
   /** Scala implicit `match` term */
   object ImplicitMatch {
 
-    /** Creates a pattern match `implicit match { <cases: List[CaseDef]> }` */
+    /** Creates a pattern match `implied match { <cases: List[CaseDef]> }` */
     def apply(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
       kernel.ImplicitMatch_apply(cases)
 
     def copy(original: Tree)(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
       kernel.ImplicitMatch_copy(original)(cases)
 
-    /** Matches a pattern match `implicit match { <cases: List[CaseDef]> }` */
+    /** Matches a pattern match `implied match { <cases: List[CaseDef]> }` */
     def unapply(tree: Tree)(implicit ctx: Context): Option[List[CaseDef]] =
       kernel.matchImplicitMatch(tree).map(_.cases)
 
diff --git a/tests/invalid/neg/implicitMatch-ambiguous.scala b/tests/invalid/neg/implicitMatch-ambiguous.scala
@@ -4,7 +4,7 @@ object Test {
   implicit val a1: A = new A
   implicit val a2: A = new A
 
-  inline def f: Any = implicit match {
+  inline def f: Any = implied match {
     case _: A => ???  // error: ambiguous implicits
   }
 
diff --git a/tests/invalid/run/typelevel.scala b/tests/invalid/run/typelevel.scala
@@ -153,7 +153,7 @@ object Test extends App {
     case S[type N] => toInt[N] + 1
   }
 
-  inline def toInt1[T]: Nat = implicit match {
+  inline def toInt1[T]: Nat = implied match {
     case C[type T, type U], T =:= U =>
     case T <:< S[type N] => toInt[N] + 1
   }
diff --git a/tests/neg/implicit-match-ambiguous-bind.scala b/tests/neg/implicit-match-ambiguous-bind.scala
@@ -2,7 +2,7 @@ object `implicit-match-ambiguous-bind` {
   case class Box[T](value: T)
   implicit val ibox: Box[Int] = Box(0)
   implicit val sbox: Box[String] = Box("")
-  inline def unbox = implicit match {
+  inline def unbox = implied match {
     case b: Box[t] => b.value // error
   }
   val unboxed = unbox
diff --git a/tests/neg/implicitMatch-syntax.scala b/tests/neg/implicitMatch-syntax.scala
@@ -2,32 +2,32 @@ object Test {
   import collection.immutable.TreeSet
   import collection.immutable.HashSet
 
-  inline def f1[T] = implicit implicit match { // error: repeated modifier // error: illegal modifier
+  inline def f1[T] = implied implied match { // error: repeated modifier // error: illegal modifier
     case ord: Ordered[T] => new TreeSet[T] // error: no implicit
     case _ => new HashSet[T]
 
   }
 
-  inline def f2[T] = implicit erased match { // error: illegal modifier
+  inline def f2[T] = implied erased match { // error: illegal modifier
     case ord: Ordered[T] => new TreeSet[T] // error: no implicit
     case _ => new HashSet[T]
   }
 
-  inline def f3[T] = erased implicit match { // error: illegal modifier
+  inline def f3[T] = erased implied match { // error: illegal modifier
     case ord: Ordered[T] => new TreeSet[T] // error: no implicit
     case _ => new HashSet[T]
   }
 
-  inline def f4() = implicit match {
+  inline def f4() = implied match {
     case Nil => ???     // error: not a legal pattern
     case x :: xs => ??? // error: not a legal pattern
   }
 
-  inline def f5[T] = locally { implicit match { // Ok
+  inline def f5[T] = locally { implied match { // Ok
     case _ => new HashSet[T]
   }}
 
-  def f6[T] = implicit match { // error: implicit match cannot be used here
+  def f6[T] = implied match { // error: implied match cannot be used here
     case _ => new HashSet[T]
   }
 }
diff --git a/tests/neg/typeclass-derivation2.scala b/tests/neg/typeclass-derivation2.scala
@@ -213,7 +213,7 @@ object Show {
   import scala.compiletime.{erasedValue, error}
   import TypeLevel._
 
-  inline def tryShow[T](x: T): String = implicit match {
+  inline def tryShow[T](x: T): String = implied match {
     case s: Show[T] => s.show(x)
   }
 
diff --git a/tests/pending/pos/implicit-match.scala b/tests/pending/pos/implicit-match.scala
@@ -1,9 +1,9 @@
-// Implicit matches that bind parameters don't work yet.
+// implied matches that bind parameters don't work yet.
 object `implicit-match` {
   object invariant {
     case class Box[T](value: T)
     implicit val box: Box[Int] = Box(0)
-    inline def unbox <: Any = implicit match {
+    inline def unbox <: Any = implied match {
       case b: Box[t] => b.value
     }
     val i: Int = unbox
@@ -14,7 +14,7 @@ object `implicit-match` {
   object covariant {
     case class Box[+T](value: T)
     implicit val box: Box[Int] = Box(0)
-    inline def unbox <: Any = implicit match {
+    inline def unbox <: Any = implied match {
       case b: Box[t] => b.value
     }
     val i: Int = unbox
@@ -25,7 +25,7 @@ object `implicit-match` {
   object contravariant {
     case class TrashCan[-T](trash: T => Unit)
     implicit val trashCan: TrashCan[Int] = TrashCan { i => ; }
-    inline def trash <: Nothing => Unit = implicit match {
+    inline def trash <: Nothing => Unit = implied match {
       case c: TrashCan[t] => c.trash
     }
     val t1: Int => Unit = trash
diff --git a/tests/pos-special/typeclass-scaling.scala b/tests/pos-special/typeclass-scaling.scala
@@ -217,7 +217,7 @@ object typeclasses {
     import compiletime._
     import scala.deriving._
 
-    inline def tryEql[TT](x: TT, y: TT): Boolean = implicit match {
+    inline def tryEql[TT](x: TT, y: TT): Boolean = implied match {
       case eq: Eq[TT] => eq.eql(x, y)
     }
 
@@ -237,7 +237,7 @@ object typeclasses {
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
-            implicit match {
+            implied match {
               case m: Mirror.ProductOf[`alt`] => eqlElems[m.MirroredElemTypes](0)(x, y)
             }
           else eqlCases[alts1](n + 1)(x, y, ord)
@@ -274,7 +274,7 @@ object typeclasses {
 
     def nextInt(buf: mutable.ListBuffer[Int]): Int = try buf.head finally buf.trimStart(1)
 
-    inline def tryPickle[T](buf: mutable.ListBuffer[Int], x: T): Unit = implicit match {
+    inline def tryPickle[T](buf: mutable.ListBuffer[Int], x: T): Unit = implied match {
       case pkl: Pickler[T] => pkl.pickle(buf, x)
     }
 
@@ -290,14 +290,14 @@ object typeclasses {
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
-            implicit match {
+            implied match {
               case m: Mirror.ProductOf[`alt`] => pickleElems[m.MirroredElemTypes](0)(buf, x)
             }
           else pickleCases[alts1](n + 1)(buf, x, ord)
         case _: Unit =>
       }
 
-    inline def tryUnpickle[T](buf: mutable.ListBuffer[Int]): T = implicit match {
+    inline def tryUnpickle[T](buf: mutable.ListBuffer[Int]): T = implied match {
       case pkl: Pickler[T] => pkl.unpickle(buf)
     }
 
@@ -324,7 +324,7 @@ object typeclasses {
       inline erasedValue[Alts] match {
         case _: (alt *: alts1) =>
           if (ord == n)
-            implicit match {
+            implied match {
               case m: Mirror.ProductOf[`alt` & T] =>
                 unpickleCase[`alt` & T, m.MirroredElemTypes](buf, m)
             }
diff --git a/tests/pos/i5938.scala b/tests/pos/i5938.scala
@@ -1,8 +1,8 @@
 trait Link[T, A]
 
-inline def link[T] = implicit match {
+inline def link[T] = implied match {
   case _: Link[T, s] =>
-    implicit match {
+    implied match {
       case stuff: s => stuff
     }
 }
diff --git a/tests/pos/i6014-gadt.scala b/tests/pos/i6014-gadt.scala
@@ -10,7 +10,7 @@ object Test1 {
 }
 
 object Test2 {
-  inline def summon[T] = implicit match {
+  inline def summon[T] = implied match {
     case t: T => t
   }
 
@@ -25,7 +25,7 @@ object Test2 {
 }
 
 object Test3 {
-  inline def summon[T] = implicit match {
+  inline def summon[T] = implied match {
     case t: T => t
   }
 
@@ -42,7 +42,7 @@ object Test3 {
 }
 
 object Test4 {
-  inline def summon[T] = implicit match {
+  inline def summon[T] = implied match {
     case t: T => t
   }
 
diff --git a/tests/pos/implicit-match-and-inline-match.scala b/tests/pos/implicit-match-and-inline-match.scala
@@ -5,7 +5,7 @@ object `implicit-match-and-inline-match` {
   implicit val ibox: Box[Int] = Box(0)
 
   object a {
-    inline def isTheBoxInScopeAnInt = implicit match {
+    inline def isTheBoxInScopeAnInt = implied match {
       case _: Box[t] => inline erasedValue[t] match {
         case _: Int => true
       }
@@ -14,7 +14,7 @@ object `implicit-match-and-inline-match` {
   }
 
   object b {
-    inline def isTheBoxInScopeAnInt = implicit match {
+    inline def isTheBoxInScopeAnInt = implied match {
       case _: Box[t] => inline 0 match {
         case _: t => true
       }
diff --git a/tests/pos/implicit-match-nested.scala b/tests/pos/implicit-match-nested.scala
@@ -6,8 +6,8 @@ object `implicit-match-nested` {
   implicit val b1: B[Int] = B[Int]()
   implicit val b2: B[String] = B[String]()
 
-  inline def locateB <: B[_] = implicit match {
-    case _: A[t] => implicit match {
+  inline def locateB <: B[_] = implied match {
+    case _: A[t] => implied match {
       case b: B[`t`] => b
     }
   }
diff --git a/tests/pos/inline-separate/A_1.scala b/tests/pos/inline-separate/A_1.scala
diff --git a/tests/run/companion-loading.scala b/tests/run/companion-loading.scala
diff --git a/tests/run/implicitMatch.scala b/tests/run/implicitMatch.scala
diff --git a/tests/run/typeclass-derivation1.scala b/tests/run/typeclass-derivation1.scala
diff --git a/tests/run/typeclass-derivation2.scala b/tests/run/typeclass-derivation2.scala
diff --git a/tests/run/typeclass-derivation2a.scala b/tests/run/typeclass-derivation2a.scala
diff --git a/tests/run/typeclass-derivation2b.scala b/tests/run/typeclass-derivation2b.scala
diff --git a/tests/run/typeclass-derivation2c.scala b/tests/run/typeclass-derivation2c.scala
diff --git a/tests/run/typeclass-derivation2d.scala b/tests/run/typeclass-derivation2d.scala
diff --git a/tests/run/typeclass-derivation3.scala b/tests/run/typeclass-derivation3.scala

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>`
`111`	`111`	`.appliedTo(Literal(Constant(s"native method stub"))))`
`112`	`112`
`113`	`113`	`}`
`114`		`- else ddef`
	`114`	`+ ddef`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ object Test {`
`4`	`4`	`implicit val a1: A = new A`
`5`	`5`	`implicit val a2: A = new A`
`6`	`6`
`7`		`- inline def f: Any = implicit match {`
	`7`	`+ inline def f: Any = implied match {`
`8`	`8`	`case _: A => ??? // error: ambiguous implicits`
`9`	`9`	`}`
`10`	`10`