Distinguish between Implicit and Implied flags

odersky · odersky · commit f29af7137fac · 2019-02-09T14:58:57.000+01:00
We need that for pretty printing, and generally, to distinguish
the two styles for implicits.
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -344,8 +344,6 @@ object desugar {
     val isObject = mods.is(Module)
     val isCaseClass  = mods.is(Case) && !isObject
     val isCaseObject = mods.is(Case) && isObject
-    val isImplicit = mods.is(Implicit)
-    val isInstance = isImplicit && mods.mods.exists(_.isInstanceOf[Mod.Instance])
     val isEnum = mods.isEnumClass && !mods.is(Module)
     def isEnumCase = mods.isEnumCase
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
@@ -666,7 +664,7 @@ object desugar {
     //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
     //       new C[Ts](p11, ..., p1N) ... (pM1, ..., pMN) =
     val implicitWrappers =
-      if (!isImplicit)
+      if (!mods.is(ImplicitOrImplied))
         Nil
       else if (ctx.owner is Package) {
         ctx.error(TopLevelImplicitClass(cdef), cdef.sourcePos)
@@ -676,7 +674,7 @@ object desugar {
         ctx.error(ImplicitCaseClass(cdef), cdef.sourcePos)
         Nil
       }
-      else if (arity != 1 && !isInstance) {
+      else if (arity != 1 && !mods.is(Implied)) {
         ctx.error(ImplicitClassPrimaryConstructorArity(), cdef.sourcePos)
         Nil
       }
@@ -690,7 +688,7 @@ object desugar {
         // implicit wrapper is typechecked in same scope as constructor, so
         // we can reuse the constructor parameters; no derived params are needed.
         DefDef(className.toTermName, constrTparams, defParamss, classTypeRef, creatorExpr)
-          .withMods(companionMods | Synthetic | Implicit | Final)
+          .withMods(companionMods | mods.flags & ImplicitOrImplied | Synthetic | Final)
           .withSpan(cdef.span) :: Nil
       }
 
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -152,7 +152,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Enum()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Enum)
 
-    case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
+    case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implied)
   }
 
   /** Modifiers and annotations for definitions
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -384,6 +384,8 @@ object Flags {
   /** Symbol is a Java default method */
   final val DefaultMethod: FlagSet = termFlag(38, "<defaultmethod>")
 
+  final val Implied: FlagSet = commonFlag(39, "implied")
+
   /** Symbol is an enum class or enum case (if used with case) */
   final val Enum: FlagSet = commonFlag(40, "<enum>")
 
@@ -460,7 +462,7 @@ object Flags {
 
   /** Flags representing source modifiers */
   private val CommonSourceModifierFlags: FlagSet =
-    commonFlags(Private, Protected, Final, Case, Implicit, Override, JavaStatic)
+    commonFlags(Private, Protected, Final, Case, Implicit, Implied, Override, JavaStatic)
 
   final val TypeSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque
@@ -485,7 +487,7 @@ object Flags {
     HigherKinded.toCommonFlags | Param | ParamAccessor.toCommonFlags |
     Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
-    Extension.toCommonFlags | NonMember | ImplicitCommon | Permanent | Synthetic |
+    Extension.toCommonFlags | NonMember | ImplicitCommon | Implied | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
@@ -541,7 +543,7 @@ object Flags {
 
   /** Flags that can apply to a module val */
   final val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
-    Override | Final | Method | Implicit | Lazy |
+    Override | Final | Method | Implicit | Implied | Lazy |
     Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Erased
 
   /** Flags that can apply to a module class */
@@ -586,6 +588,8 @@ object Flags {
   /** An inline method or inline argument proxy */
   final val InlineOrProxy: FlagSet = Inline | InlineProxy
 
+  final val ImplicitOrImplied = Implicit | Implied
+
   /** Assumed to be pure */
   final val StableOrErased: FlagSet = StableRealizable | Erased
 
@@ -601,9 +605,6 @@ object Flags {
   /** An inline method */
   final val InlineMethod: FlagConjunction = allOf(Inline, Method)
 
-  /** An implicit inline method */
-  final val ImplicitInlineMethod: FlagConjunction = allOf(Inline, Implicit, Method)
-
   /** An inline parameter */
   final val InlineParam: FlagConjunction = allOf(Inline, Param)
 
diff --git a/compiler/src/dotty/tools/dotc/core/Scopes.scala b/compiler/src/dotty/tools/dotc/core/Scopes.scala
@@ -9,7 +9,7 @@ package core
 
 import Symbols._
 import Types.{TermRef, NoPrefix}
-import Flags.Implicit
+import Flags._
 import Names._
 import Contexts._
 import Denotations._
@@ -409,7 +409,7 @@ object Scopes {
       var irefs = new mutable.ListBuffer[TermRef]
       var e = lastEntry
       while (e ne null) {
-        if (e.sym is Implicit) {
+        if (e.sym is ImplicitOrImplied) {
           val d = e.sym.denot
           irefs += TermRef(NoPrefix, d.symbol.asTerm).withDenot(d)
         }
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1872,8 +1872,8 @@ object SymDenotations {
             maybeAdd(name)
         val ownSyms =
           if (keepOnly eq implicitFilter)
-            if (this is Package) Iterator.empty
-            else info.decls.iterator filter (_ is Implicit)
+            if (this is Package) Iterator.empty // !!!!
+            else info.decls.iterator filter (_ is ImplicitOrImplied)
           else info.decls.iterator
         for (sym <- ownSyms) maybeAdd(sym.name)
         names
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -137,7 +137,7 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {
         }
       }
       // Give up and give generic errors.
-      else if (cycleSym.is(Implicit, butNot = Method) && cycleSym.owner.isTerm)
+      else if (cycleSym.is(ImplicitOrImplied, butNot = Method) && cycleSym.owner.isTerm)
         CyclicReferenceInvolvingImplicit(cycleSym)
       else
         CyclicReferenceInvolving(denot)
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -790,7 +790,7 @@ object Types {
     /** The set of implicit members of this type */
     final def implicitMembers(implicit ctx: Context): List[TermRef] = track("implicitMembers") {
       memberDenots(implicitFilter,
-          (name, buf) => buf ++= member(name).altsWith(_ is Implicit))
+          (name, buf) => buf ++= member(name).altsWith(_ is ImplicitOrImplied))
         .toList.map(d => TermRef(this, d.symbol.asTerm))
     }
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -180,6 +180,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   SEALED
                   CASE
                   IMPLICIT
+                  IMPLIED
                   ERASED
                   LAZY
                   OVERRIDE
@@ -324,7 +325,8 @@ object TastyFormat {
   final val OPAQUE = 35
   final val EXTENSION = 36
   final val GIVEN = 37
-  final val PARAMsetter = 38
+  final val IMPLIED = 38
+  final val PARAMsetter = 39
 
   // Cat. 2:    tag Nat
 
@@ -475,6 +477,7 @@ object TastyFormat {
        | SEALED
        | CASE
        | IMPLICIT
+       | IMPLIED
        | ERASED
        | LAZY
        | OVERRIDE
@@ -535,6 +538,7 @@ object TastyFormat {
     case SEALED => "SEALED"
     case CASE => "CASE"
     case IMPLICIT => "IMPLICIT"
+    case IMPLIED => "IMPLIED"
     case ERASED => "ERASED"
     case LAZY => "LAZY"
     case OVERRIDE => "OVERRIDE"
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -646,6 +646,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Scala2x) writeByte(SCALA2X)
     if (isTerm) {
       if (flags is Implicit) writeByte(IMPLICIT)
+      if (flags is Implied) writeByte(IMPLIED)
       if (flags is Erased) writeByte(ERASED)
       if (flags.is(Lazy, butNot = Module)) writeByte(LAZY)
       if (flags is AbsOverride) { writeByte(ABSTRACT); writeByte(OVERRIDE) }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -609,6 +609,7 @@ class TreeUnpickler(reader: TastyReader,
           case SEALED => addFlag(Sealed)
           case CASE => addFlag(Case)
           case IMPLICIT => addFlag(Implicit)
+          case IMPLIED => addFlag(Implied)
           case ERASED => addFlag(Erased)
           case LAZY => addFlag(Lazy)
           case OVERRIDE => addFlag(Override)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -783,7 +783,7 @@ object Parsers {
       def functionRest(params: List[Tree]): Tree =
         atSpan(start, accept(ARROW)) {
           val t = typ()
-          if (imods.is(Implicit | Given | Erased)) new FunctionWithMods(params, t, imods)
+          if (imods.is(Given | Erased)) new FunctionWithMods(params, t, imods)
           else Function(params, t)
         }
       def funArgTypesRest(first: Tree, following: () => Tree) = {
@@ -817,7 +817,7 @@ object Parsers {
             }
             openParens.change(LPAREN, -1)
             accept(RPAREN)
-            if (imods.is(Implicit) || isValParamList || in.token == ARROW)
+            if (isValParamList || in.token == ARROW)
               functionRest(ts)
             else {
               val ts1 =
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -771,7 +771,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 &~= Implicit // drop implicit from classes
+    if (homogenizedView && mods.flags.isTypeFlags) flagMask &~= ImplicitOrImplied // drop implicit/implied from classes
     val flags = (if (sym.exists) sym.flags else (mods.flags)) & flagMask
     val flagsText = if (flags.isEmpty) "" else keywordStr(flags.toString)
     val annotations =
diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
@@ -589,7 +589,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     val abs = sym.is(Abstract) || sym.is(Deferred) || absOver
     val over = sym.is(Override) || absOver
     new api.Modifiers(abs, over, sym.is(Final), sym.is(Sealed),
-      sym.is(Implicit), sym.is(Lazy), sym.is(Macro), sym.isSuperAccessor)
+      sym.is(ImplicitOrImplied), sym.is(Lazy), sym.is(Macro), sym.isSuperAccessor)
   }
 
   def apiAnnotations(s: Symbol): List[api.Annotation] = {
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/FlagsOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/FlagsOpsImpl.scala
@@ -21,6 +21,7 @@ trait FlagsOpsImpl extends scala.tasty.reflect.FlagsOps with CoreImpl {
     def Sealed: Flags = core.Flags.Sealed
     def Case: Flags = core.Flags.Case
     def Implicit: Flags = core.Flags.Implicit
+    def Implied = core.Flags.Implied
     def Erased: Flags = core.Flags.Erased
     def Lazy: Flags = core.Flags.Lazy
     def Override: Flags = core.Flags.Override
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -376,7 +376,7 @@ object Checking {
           ))
       fail(ParamsNoInline(sym.owner))
 
-    if (sym.is(ImplicitCommon)) {
+    if (sym.is(ImplicitCommon | Implied)) {
       if (sym.owner.is(Package))
         fail(TopLevelCantBeImplicit(sym))
       if (sym.isType)
diff --git a/compiler/src/dotty/tools/dotc/typer/Deriving.scala b/compiler/src/dotty/tools/dotc/typer/Deriving.scala
@@ -145,7 +145,7 @@ trait Deriving { this: Typer =>
       if (ctx.denotNamed(instanceName).exists) {
         if (reportErrors) ctx.error(i"duplicate typeclass derivation for $clsName", pos)
       }
-      else add(newMethod(instanceName, info, pos.span, Implicit))
+      else add(newMethod(instanceName, info, pos.span, Implied))
     }
 
     /** Check derived type tree `derived` for the following well-formedness conditions:
diff --git a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -102,7 +102,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
     } else
       for {
         renamed <- reverseMapping.keys
-        denot <- pre.member(reverseMapping(renamed)).altsWith(_ is Implicit)
+        denot <- pre.member(reverseMapping(renamed)).altsWith(_ is ImplicitOrImplied)
       } yield {
         val original = reverseMapping(renamed)
         val ref = TermRef(pre, original, denot)
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -1049,7 +1049,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           case Some(x) => x > 1 || x == 1 && !boundSym.is(Method)
           case none => true
         }
-      } && !boundSym.is(ImplicitInlineMethod)
+      } && !(boundSym.is(InlineMethod) && boundSym.is(ImplicitOrImplied))
 
       val inlineBindings = new TreeMap {
         override def transform(t: Tree)(implicit ctx: Context) = t match {
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -342,7 +342,7 @@ class Namer { typer: Typer =>
     tree match {
       case tree: TypeDef if tree.isClassDef =>
         val name = checkNoConflict(tree.name).asTypeName
-        val flags = checkFlags(tree.mods.flags &~ Implicit)
+        val flags = checkFlags(tree.mods.flags &~ ImplicitOrImplied)
         val cls =
           createOrRefine[ClassSymbol](tree, name, flags,
             cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
@@ -954,7 +954,7 @@ class Namer { typer: Typer =>
               val ptype = typedAheadType(tpt).tpe appliedTo targs1.tpes
               if (ptype.typeParams.isEmpty) ptype
               else {
-                if (denot.is(ModuleClass) && denot.sourceModule.is(Implicit))
+                if (denot.is(ModuleClass) && denot.sourceModule.is(ImplicitOrImplied))
                   missingType(denot.symbol, "parent ")(creationContext)
                 fullyDefinedType(typedAheadExpr(parent).tpe, "class parent", parent.span)
               }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1477,7 +1477,7 @@ class Typer extends Namer
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(implicit ctx: Context): Tree = track("typedValDef") {
     val ValDef(name, tpt, _) = vdef
     completeAnnotations(vdef, sym)
-    if (sym is Implicit) checkImplicitConversionDefOK(sym)
+    if (sym is ImplicitOrImplied) checkImplicitConversionDefOK(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
     val rhs1 = vdef.rhs match {
       case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
@@ -1532,7 +1532,7 @@ class Typer extends Namer
     val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
     val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef])
     vparamss1.foreach(checkNoForwardDependencies)
-    if (sym is Implicit) checkImplicitConversionDefOK(sym)
+    if (sym is ImplicitOrImplied) checkImplicitConversionDefOK(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
 
     var rhsCtx = ctx

Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {`
`152`	`152`
`153`	`153`	`case class Enum()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Enum)`
`154`	`154`
`155`		`- case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)`
	`155`	`+ case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implied)`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`/** Modifiers and annotations for definitions`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`	`// Give up and give generic errors.`
`140`		`- else if (cycleSym.is(Implicit, butNot = Method) && cycleSym.owner.isTerm)`
	`140`	`+ else if (cycleSym.is(ImplicitOrImplied, butNot = Method) && cycleSym.owner.isTerm)`
`141`	`141`	`CyclicReferenceInvolvingImplicit(cycleSym)`
`142`	`142`	`else`
`143`	`143`	`CyclicReferenceInvolving(denot)`
Original file line number	Diff line number	Diff line change
`@@ -790,7 +790,7 @@ object Types {`
`790`	`790`	`/** The set of implicit members of this type */`
`791`	`791`	`final def implicitMembers(implicit ctx: Context): List[TermRef] = track("implicitMembers") {`
`792`	`792`	`memberDenots(implicitFilter,`
`793`		`- (name, buf) => buf ++= member(name).altsWith(_ is Implicit))`
	`793`	`+ (name, buf) => buf ++= member(name).altsWith(_ is ImplicitOrImplied))`
`794`	`794`	`.toList.map(d => TermRef(this, d.symbol.asTerm))`
`795`	`795`	`}`
`796`	`796`