Rename implied to delegate

Author: odersky

community-build/community-projects/scalatest

@@ -392,7 +392,7 @@ object Flags {
   /** Symbol is a Java default method */
   final val DefaultMethod: FlagSet = termFlag(38, "<defaultmethod>")
 
-  final val Implied: FlagSet = commonFlag(39, "implied")
+  final val Implied: FlagSet = commonFlag(39, "delegate")
 
   /** Symbol is an enum class or enum case (if used with case) */
   final val Enum: FlagSet = commonFlag(40, "<enum>")

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

@@ -121,7 +121,7 @@ object Completion {
     if (buffer.mode != Mode.None) {
       path match {
         case Select(qual, _) :: _                    => buffer.addMemberCompletions(qual)
-        case Import(_, expr, _) :: _                 => buffer.addMemberCompletions(expr) // TODO: distinguish implied from non-implied
+        case Import(_, expr, _) :: _                 => buffer.addMemberCompletions(expr) // TODO: distinguish delegate from non-delegate
         case (_: Thicket) :: Import(_, expr, _) :: _ => buffer.addMemberCompletions(expr)
         case _                                       => buffer.addScopeCompletions
       }

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -1266,7 +1266,7 @@ object Parsers {
      *                      |  SimpleExpr1 ArgumentExprs `=' Expr
      *                      |  Expr2
      *                      |  [‘inline’] Expr2 `match' `{' CaseClauses `}'
-     *                      |  `implied' `match' `{' ImplicitCaseClauses `}'
+     *                      |  `delegate' `match' `{' ImplicitCaseClauses `}'
      *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
      *  Binding           ::=  (id | `_') [`:' Type]
      *  Expr2             ::=  PostfixExpr [Ascription]
@@ -1470,7 +1470,7 @@ object Parsers {
      */
     def impliedMatch(start: Int, imods: Modifiers) = {
       def markFirstIllegal(mods: List[Mod]) = mods match {
-        case mod :: _ => syntaxError(em"illegal modifier for implied match", mod.span)
+        case mod :: _ => syntaxError(em"illegal modifier for delegate match", mod.span)
         case _ =>
       }
       imods.mods match {
@@ -1485,7 +1485,7 @@ object Parsers {
           case pat => isVarPattern(pat)
         }
         if (!isImplicitPattern(pat))
-          syntaxError(em"not a legal pattern for an implied match", pat.span)
+          syntaxError(em"not a legal pattern for a delegate match", pat.span)
       }
       result
     }
@@ -2351,8 +2351,8 @@ object Parsers {
 
     type ImportConstr = (Boolean, Tree, List[Tree]) => Tree
 
-    /** Import  ::= import [implied] [ImportExpr {`,' ImportExpr}
-     *  Export  ::= export [implied] [ImportExpr {`,' ImportExpr}
+    /** Import  ::= import [delegate] [ImportExpr {`,' ImportExpr}
+     *  Export  ::= export [delegate] [ImportExpr {`,' ImportExpr}
      */
     def importClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
       val offset = accept(leading)
@@ -2383,7 +2383,7 @@ object Parsers {
           wildcardIdent() :: Nil
         case FOR =>
           if (!importImplied)
-              syntaxError(em"`for` qualifier only allowed in `import implied`")
+              syntaxError(em"`for` qualifier only allowed in `import delegate`")
           atSpan(in.skipToken()) {
             var t = infixType()
             while (in.token == COMMA) {

compiler/src/dotty/tools/dotc/parsing/Parsers.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, "delegate")
   final val GIVEN = 65;            enter(GIVEN, "given")
   final val EXPORT = 66;           enter(EXPORT, "export")
   final val MACRO = 67;            enter(MACRO, "macro") // TODO: remove

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

@@ -509,7 +509,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case id :: Nil => toText(id)
           case _ => "{" ~ Text(selectors map selectorText, ", ") ~ "}"
         }
-        keywordText("import ") ~ (keywordText("implied ") provided importImplied) ~
+        keywordText("import ") ~ (keywordText("delegate ") provided importImplied) ~
         toTextLocal(expr) ~ "." ~ selectorsText
       case packageDef: PackageDef =>
         packageDefText(packageDef)
@@ -815,7 +815,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       if (ctx.settings.YdebugFlags.value) AnyFlags
       else if (suppressKw) PrintableFlags(isType) &~ Private
       else PrintableFlags(isType)
-    if (homogenizedView && mods.flags.isTypeFlags) flagMask &~= ImplicitOrImplied // drop implicit/implied from classes
+    if (homogenizedView && mods.flags.isTypeFlags) flagMask &~= ImplicitOrImplied // drop implicit/delegate from classes
     val rawFlags = if (sym.exists) sym.flags else mods.flags
     if (rawFlags.is(Param)) flagMask = flagMask &~ Given
     val flags = rawFlags & flagMask

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -1317,7 +1317,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
      *
      *     T => R  <:s  U => R
      *
-     *  Also: If a compared type refers to an implied object or its module class, use
+     *  Also: If a compared type refers to an delegate or its module class, use
      *  the intersection of its parent classes instead.
      */
     def isAsSpecificValueType(tp1: Type, tp2: Type)(implicit ctx: Context) =
@@ -1342,22 +1342,22 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         (prepare(tp1) relaxed_<:< prepare(tp2)) || viewExists(tp1, tp2)
       }
 
-    /** Widen the result type of synthetic implied methods from the implementation class to the
+    /** Widen the result type of synthetic delegate methods from the implementation class to the
      *  type that's implemented. Example
      *
-     *      implied I[X] for T { ... }
+     *      delegate I[X] for T { ... }
      *
      *  This desugars to
      *
      *      class I[X] extends T { ... }
-     *      implied def I[X]: I[X] = new I[X]
+     *      implicit def I[X]: I[X] = new I[X]
      *
      *  To compare specificity we should compare with `T`, not with its implementation `I[X]`.
-     *  No such widening is performed for implied aliases, which are not synthetic. E.g.
+     *  No such widening is performed for delegate aliases, which are not synthetic. E.g.
      *
-     *      implied J[X] for T = rhs
+     *      delegate J[X] for T = rhs
      *
-     *  already has the right result type `T`. Neither is widening performed for implied
+     *  already has the right result type `T`. Neither is widening performed for delegate
      *  objects, since these are anyway taken to be more specific than methods
      *  (by condition 3a above).
      */

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

@@ -1158,7 +1158,7 @@ trait Implicits { self: Typer =>
           case fail: SearchFailureType =>
 
             def hiddenImplicitNote(s: SearchSuccess) =
-              em"\n\nNote: implied instance ${s.ref.symbol.showLocated} was not considered because it was not imported with an `import implied`."
+              em"\n\nNote: delegate ${s.ref.symbol.showLocated} was not considered because it was not imported with `import delegate`."
 
             def FindHiddenImplicitsCtx(ctx: Context): Context =
               if (ctx == NoContext) ctx

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

@@ -28,7 +28,7 @@ object ImportInfo {
  *  @param   selectors     The selector clauses
  *  @param   symNameOpt    Optionally, the name of the import symbol. None for root imports.
  *                         Defined for all explicit imports from ident or select nodes.
- *  @param   importImplied true if this is an implied import
+ *  @param   importImplied true if this is a delegate import
  *  @param   isRootImport  true if this is one of the implicit imports of scala, java.lang,
  *                         scala.Predef or dotty.DottyPredef in the start context, false otherwise.
  */

compiler/src/dotty/tools/dotc/typer/ImportInfo.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 implied match
+     *                            EmptyTree for a delegate match
      *   @param     scrutType     its fully defined type, or
-     *                            ImplicitScrutineeTypeRef for an implied match
+     *                            ImplicitScrutineeTypeRef for a delegate 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,10 +1036,10 @@ 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 implied match with
+                em"""cannot reduce delegate match with
                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
               else
-                em"""cannot reduce inline match with
+                em"""cannot reduce delegate match with
                     | scrutinee:  $sel : ${selType}
                     | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
             errorTree(tree, msg)