Change implied -> implicit in comments and error messages

Author: odersky

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -57,7 +57,7 @@ Standard-Section: "ASTs" TopLevelStat*
   Stat          = Term
                   ValOrDefDef
                   TYPEDEF        Length NameRef (type_Term | Template) Modifier*   -- modifiers type name (= type | bounds)  |  moifiers class name template
-                  IMPORT         Length [IMPLIED] qual_Term Selector*              -- import implied? qual selectors
+                  IMPORT         Length [IMPLIED] qual_Term Selector*              -- import implicit? qual selectors
   ValOrDefDef   = VALDEF         Length NameRef type_Term rhs_Term? Modifier*      -- modifiers val name : type (= rhs)?
                   DEFDEF         Length NameRef TypeParam* Params* returnType_Term rhs_Term?
                                         Modifier*                                  -- modifiers def name [typeparams] paramss : returnType (= rhs)?

compiler/src/dotty/tools/dotc/interactive/Completion.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 implicit from non-implicit
         case (_: Thicket) :: Import(_, expr, _) :: _ => buffer.addMemberCompletions(expr)
         case _                                       => buffer.addScopeCompletions
       }

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

@@ -504,7 +504,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("implicit ") provided importImplied) ~
         toTextLocal(expr) ~ "." ~ selectorsText
       case packageDef: PackageDef =>
         packageDefText(packageDef)

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

@@ -1350,22 +1350,22 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         (flip(tp1) relaxed_<:< flip(tp2)) || viewExists(tp1, tp2)
       }
 
-    /** Widen the result type of synthetic implied methods from the implementation class to the
+    /** Widen the result type of synthetic implicit methods from the implementation class to the
      *  type that's implemented. Example
      *
-     *      implied I[X] for T { ... }
+     *      implicit 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 implicit aliases, which are not synthetic. E.g.
      *
-     *      implied J[X] for T = rhs
+     *      implicit 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 implicit
      *  objects, since these are anyway taken to be more specific than methods
      *  (by condition 3a above).
      */

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

@@ -247,7 +247,7 @@ trait Deriving { this: Typer =>
     }
 
     /** If any of the instances has a companion with a `derived` member
-     *  that refers to `scala.reflect.Generic`, add an implied instance
+     *  that refers to `scala.reflect.Generic`, add an implicit instance
      *  of `Generic`. Note: this is just an optimization to avoid possible
      *  code duplication. Generic instances are created on the fly if they
      *  are missing from the companion.

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

@@ -918,7 +918,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: implicit instance ${s.ref.symbol.showLocated} was not considered because it was not imported with an `import implicit`."
 
             def FindHiddenImplicitsCtx(ctx: Context): Context =
               if (ctx == NoContext) ctx

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

@@ -26,7 +26,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 an implicit 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.
  */

library/src/scala/Eql.scala

@@ -12,12 +12,12 @@ sealed trait Eql[-L, -R]
  *  the compiler (see Implicits.synthesizedEq), so they are not included here.
  */
 object Eql {
-  /** A non-implied universal `Eql` instance. */
+  /** A non-implicit universal `Eql` instance. */
   object derived extends Eql[Any, Any]
 
   /** A fall-back instance to compare values of any types.
-   *  Even though this method is not declared implied, the compiler will
-   *  compute implied instances as solutions to `Eql[T, U]` queries if
+   *  Even though this method is not declared implicit, the compiler will
+   *  compute implicit instances as solutions to `Eql[T, U]` queries if
    *  the rules of multiversal equality require it.
    */
   def eqlAny[L, R]: Eql[L, R] = derived

library/src/scala/tasty/reflect/Printers.scala

@@ -554,7 +554,7 @@ trait Printers
 
         case Import(importImplied, expr, selectors) =>
           this += "import "
-          if (importImplied) this += "implied "
+          if (importImplied) this += "implied "// FIXME: change to "implicit "
           printTree(expr)
           this += "."
           printImportSelectors(selectors)

library/src/scalaShadowing/language.scala

@@ -107,7 +107,7 @@ object language {
    *  }}}
    *
    *  Implicit values of other types are not affected, and neither are implicit
-   *  classes. In particular, implied instances of the scala.Conversion class can be
+   *  classes. In particular, implicit instances of the scala.Conversion class can be
    *  defined without having to import the language feature.
    *
    *  The language import is also required to enable _uses_ of implicit conversions
@@ -119,13 +119,13 @@ object language {
    *      class A
    *      class B
    *      object B {
-   *        implied a2b for Conversion[A, B] { ... }
+   *        implicit a2b for Conversion[A, B] { ... }
    *      }
    *      object C {
-   *        implied b2a for Conversion[B, A] { ... }
+   *        implicit b2a for Conversion[B, A] { ... }
    *      }
-   *      import implied B._
-   *      import implied C._
+   *      import implicit B._
+   *      import implicit C._
    *      val x: A = new B     // language import required
    *      val x: B = new A     // no import necessary since a2b is co-defined with B
    *  }}}