Use implicit instead of implied for instance definitions

`implied` is supported as well for now, in order to the bootstrap to proceed. Will
be removed once everyone changed to `implicit`.

Author: odersky

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

@@ -1878,7 +1878,6 @@ object SymDenotations {
           throw ex
       }
 
-
       /*>|>*/ trace.onDebug(s"$tp.baseType($this)") /*<|<*/ {
         Stats.record("baseTypeOf")
         recur(tp)

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -193,9 +193,13 @@ object Parsers {
     /** Is current token a hard or soft modifier (in modifier position or not)? */
     def isModifier: Boolean = modifierTokens.contains(in.token) || in.isSoftModifier
 
-    def isBindingIntro: Boolean =
-      canStartBindingTokens.contains(in.token) &&
-      !in.isSoftModifierInModifierPosition
+    def isBindingIntro: Boolean = {
+      in.token match {
+        case USCORE | LPAREN => true
+        case IDENTIFIER | BACKQUOTED_IDENT => in.lookaheadIn(BitSet(COLON, ARROW))
+        case _ => false
+      }
+    } && !in.isSoftModifierInModifierPosition
 
     def isExprIntro: Boolean =
       canStartExpressionTokens.contains(in.token) &&
@@ -2267,12 +2271,12 @@ object Parsers {
 
     type ImportConstr = (Boolean, Tree, List[Tree]) => Tree
 
-    /** Import  ::= import [implied] [ImportExpr {`,' ImportExpr}
-     *  Export  ::= export [implied] [ImportExpr {`,' ImportExpr}
+    /** Import  ::= import [implicit] [ImportExpr {`,' ImportExpr}
+     *  Export  ::= export [implicit] [ImportExpr {`,' ImportExpr}
      */
     def importClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
       val offset = accept(leading)
-      val importImplied = in.token == IMPLIED
+      val importImplied = in.token == IMPLICIT || in.token == IMPLIED
       if (importImplied) in.nextToken()
       commaSeparated(importExpr(importImplied, mkTree)) match {
         case t :: rest =>
@@ -2582,10 +2586,16 @@ object Parsers {
         case ENUM =>
           enumDef(start, mods, atSpan(in.skipToken()) { Mod.Enum() })
         case IMPLIED =>
-          instanceDef(start, mods, atSpan(in.skipToken()) { Mod.Instance() })
+          instanceDef(start, addMod(mods, atSpan(in.skipToken()) { Mod.Instance() }))
         case _ =>
-          syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
-          EmptyTree
+          mods.mods.lastOption match {
+            case Some(impl @ Mod.Implicit()) =>
+              val strippedMods = mods.withFlags(mods.flags &~ Implicit).withMods(mods.mods.init)
+              instanceDef(start, addMod(strippedMods, Mod.Instance().withSpan(impl.span)))
+            case _ =>
+              syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
+              EmptyTree
+          }
       }
     }
 
@@ -2683,8 +2693,8 @@ object Parsers {
      *  InstanceBody   ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
      *                   |  ‘for’ Type {GivenParamClause} ‘=’ Expr
      */
-    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
-      var mods1 = addMod(mods, instanceMod)
+    def instanceDef(start: Offset, mods: Modifiers) = atSpan(start, nameStart) {
+      var mods1 = mods
       val name = if (isIdent) ident() else EmptyTermName
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val parents =
@@ -2981,9 +2991,9 @@ object Parsers {
       }
     }
 
-    /** BlockStatSeq ::= { BlockStat semi } [ResultExpr]
+    /** BlockStatSeq ::= { BlockStat semi } [Expr]
      *  BlockStat    ::= Import
-     *                 | Annotations [implicit] [lazy] Def
+     *                 | Annotations [implicit] [lazy] [erased] Def
      *                 | Annotations LocalModifiers TmplDef
      *                 | Expr1
      *                 |
@@ -3005,13 +3015,12 @@ object Parsers {
             var imods = modifiers(closureMods)
             if (isBindingIntro)
               stats += implicitClosure(start, Location.InBlock, imods)
-            else if (in.token == MATCH)
+            else if (in.token == MATCH && imods.mods == Mod.Implicit() :: Nil)
               stats += implicitMatch(start, imods)
             else
               stats +++= localDef(start, imods)
-          } else {
-            stats +++= localDef(in.offset)
           }
+          else stats +++= localDef(in.offset)
         else if (!isStatSep && (in.token != CASE)) {
           exitOnError = mustStartStat
           syntaxErrorOrIncomplete(IllegalStartOfStatement(isModifier))

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -178,7 +178,7 @@ object Tokens extends TokensCommon {
   final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   final val ENUM = 62;             enter(ENUM, "enum")
   final val ERASED = 63;           enter(ERASED, "erased")
-  final val IMPLIED = 64;          enter(IMPLIED, "implied")
+  final val IMPLIED = 64;          enter(IMPLIED, "implied")  // FIXME: remove
   final val GIVEN = 65;            enter(GIVEN, "given")
   final val EXPORT = 66;           enter(EXPORT, "export")
   final val MACRO = 67;            enter(MACRO, "macro") // TODO: remove
@@ -219,8 +219,6 @@ object Tokens extends TokensCommon {
   final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
 
-  final val canStartBindingTokens: TokenSet = identifierTokens | BitSet(USCORE, LPAREN)
-
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
   final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, IMPLIED)

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

@@ -949,7 +949,7 @@ class Namer { typer: Typer =>
 
         def whyNoForwarder(mbr: SingleDenotation): String = {
           val sym = mbr.symbol
-          if (sym.is(ImplicitOrImplied) != exp.impliedOnly) s"is ${if (exp.impliedOnly) "not " else ""}implied"
+          if (sym.is(ImplicitOrImplied) != exp.impliedOnly) s"is ${if (exp.impliedOnly) "not " else ""}implicit"
           else if (!sym.isAccessibleFrom(path.tpe)) "is not accessible"
           else if (sym.isConstructor || sym.is(ModuleClass) || sym.is(Bridge)) SKIP
           else if (cls.derivesFrom(sym.owner) &&

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -129,7 +129,7 @@ class ReplCompilerTests extends ReplTest {
   }
 
   @Test def i5897 =
-    fromInitialState { implicit state => run("implied for Int = 10") }
+    fromInitialState { implicit state => run("implicit for Int = 10") }
     .andThen         { implicit state =>
       assertEquals(
         "def Int_instance: Int",
@@ -151,7 +151,7 @@ class ReplCompilerTests extends ReplTest {
         |  def (x: T) > (y: T) = compare(x, y) > 0
         |}
         |
-        |implied IntOrd for Ord[Int] {
+        |implicit IntOrd for Ord[Int] {
         |  def compare(x: Int, y: Int) =
         |  if (x < y) -1 else if (x > y) +1 else 0
         |}

tests/neg-custom-args/conditionalWarnings.scala

@@ -3,7 +3,7 @@
 object Test {
   @deprecated def foo = ???
 
-  implied for Conversion[String, Int] = _.length
+  implicit for Conversion[String, Int] = _.length
 
   foo    // error
 

tests/neg-custom-args/implicit-conversions.scala

@@ -3,25 +3,25 @@ class B
 
 object A {
 
-  implied for Conversion[A, B] {
+  implicit for Conversion[A, B] {
     def apply(x: A): B = ???
   }
 
-  implied for Conversion[B, A] {
+  implicit for Conversion[B, A] {
     def apply(x: B): A = ???
   }
 }
 
 class C
 
 object D {
-  implied for Conversion[A, C] {
+  implicit for Conversion[A, C] {
     def apply(x: A): C = ???
   }
 }
 
 object Test {
-  import implied D._
+  import implicit D._
 
   val x1: A = new B
   val x2: B = new A  // error under -Xfatal-warnings -feature

tests/neg/derive-eq.scala

@@ -2,7 +2,7 @@
 case class One() derives Eql
 case class Two() derives Eql
 
-implied for Eql[One, Two] = Eql.derived
+implicit for Eql[One, Two] = Eql.derived
 
 enum Lst[T] derives Eql {
   case Cons(x: T, xs: Lst[T])

tests/neg/exports.check

@@ -1,29 +1,29 @@
-<1150..1150> in exports.scala
+<1152..1152> in exports.scala
 Cyclic reference involving value bar
-[1091..1094] in exports.scala
+[1093..1096] in exports.scala
 no eligible member foo at this.foo
 this.foo.foo cannot be exported because it is already a member of class Foo
-[991..997] in exports.scala
+[993..999] in exports.scala
 no eligible member concat at this
 this.concat cannot be exported because it is already a member of trait IterableOps
-<647..647> in exports.scala
+<648..648> in exports.scala
 Double definition:
 final def status: => List[String] in class Copier at line 23 and
 final def status: => List[String] in class Copier at line 24
 have the same type after erasure.
-<596..596> in exports.scala
+<597..597> in exports.scala
 Double definition:
 def status: => List[String] in class Copier at line 28 and
 final def status: => List[String] in class Copier at line 23
 have the same type after erasure.
-[785..791] in exports.scala
+[787..793] in exports.scala
 no eligible member status at this.printUnit
-this.printUnit.status cannot be exported because it is not implied
-[712..718] in exports.scala
+this.printUnit.status cannot be exported because it is not implicit
+[713..719] in exports.scala
 no eligible member bitmap at this.printUnit
-this.printUnit.bitmap cannot be exported because it is implied
-[518..525] in exports.scala
+this.printUnit.bitmap cannot be exported because it is implicit
+[519..526] in exports.scala
 no eligible member scanAll at this.scanUnit
 this.scanUnit.scanAll cannot be exported because it is not accessible
-[452..458] in exports.scala
+[453..459] in exports.scala
 no eligible member scanIt at this.scanUnit

tests/neg/exports.scala

@@ -5,7 +5,7 @@
     type PrinterType
     def print(bits: BitMap): Unit = ???
     def status: List[String] = ???
-    implied bitmap for BitMap
+    implicit bitmap for BitMap
   }
 
   class Scanner {
@@ -23,7 +23,7 @@
     export printUnit.{stat => _, _} // error: double definition
     export scanUnit._               // error: double definition
     export printUnit.bitmap         // error: no eligible member
-    export implied printUnit.status // error: no eligible member
+    export implicit printUnit.status // error: no eligible member
 
     def status: List[String] = printUnit.status ++ scanUnit.status
   }