Make implicit flags disjoint

odersky · odersky · commit d00b12334987 · 2019-05-14T18:07:52.000+02:00
Ensure that every symbol has only one of the three flags
Implciit, Impled, Given. This is a prerequisite for simplifying
the flags in the future.
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -167,11 +167,11 @@ object desugar {
     else vdef
   }
 
-  def makeImplicitParameters(tpts: List[Tree], contextualFlag: FlagSet = EmptyFlags, forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
+  def makeImplicitParameters(tpts: List[Tree], implicitFlag: FlagSet, forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
     for (tpt <- tpts) yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
        val epname = EvidenceParamName.fresh()
-       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit | contextualFlag)
+       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | implicitFlag)
     }
 
   /** 1. Expand context bounds to evidence params. E.g.,
@@ -207,7 +207,7 @@ object desugar {
     val epbuf = new ListBuffer[ValDef]
     def desugarContextBounds(rhs: Tree): Tree = rhs match {
       case ContextBounds(tbounds, cxbounds) =>
-        epbuf ++= makeImplicitParameters(cxbounds, forPrimaryConstructor = isPrimaryConstructor)
+        epbuf ++= makeImplicitParameters(cxbounds, Implicit, forPrimaryConstructor = isPrimaryConstructor)
         tbounds
       case LambdaTypeTree(tparams, body) =>
         cpy.LambdaTypeTree(rhs)(tparams, desugarContextBounds(body))
@@ -310,7 +310,7 @@ object desugar {
         meth
       case evidenceParams =>
         val vparamss1 = meth.vparamss.reverse match {
-          case (vparams @ (vparam :: _)) :: rvparamss if vparam.mods is Implicit =>
+          case (vparams @ (vparam :: _)) :: rvparamss if vparam.mods is ImplicitOrGiven =>
             ((evidenceParams ++ vparams) :: rvparamss).reverse
           case _ =>
             meth.vparamss :+ evidenceParams
@@ -321,7 +321,7 @@ object desugar {
   /** The implicit evidence parameters of `meth`, as generated by `desugar.defDef` */
   private def evidenceParams(meth: DefDef)(implicit ctx: Context): List[ValDef] =
     meth.vparamss.reverse match {
-      case (vparams @ (vparam :: _)) :: _ if vparam.mods is Implicit =>
+      case (vparams @ (vparam :: _)) :: _ if vparam.mods is ImplicitOrGiven =>
         vparams.dropWhile(!_.name.is(EvidenceParamName))
       case _ =>
         Nil
@@ -332,7 +332,7 @@ object desugar {
   private def toDefParam(tparam: TypeDef): TypeDef =
     tparam.withMods(tparam.rawMods & EmptyFlags | Param)
   private def toDefParam(vparam: ValDef): ValDef =
-    vparam.withMods(vparam.rawMods & (Implicit | Erased) | Param)
+    vparam.withMods(vparam.rawMods & (ImplicitOrGiven | Erased) | Param)
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
@@ -400,7 +400,7 @@ object desugar {
         if (isCaseClass && originalTparams.isEmpty)
           ctx.error(CaseClassMissingParamList(cdef), namePos)
         ListOfNil
-      } else if (isCaseClass && originalVparamss.head.exists(_.mods.is(Implicit))) {
+      } else if (isCaseClass && originalVparamss.head.exists(_.mods.is(ImplicitOrGiven))) {
           ctx.error("Case classes should have a non-implicit parameter list", namePos)
         ListOfNil
       }
@@ -495,7 +495,7 @@ object desugar {
     // new C[Ts](paramss)
     lazy val creatorExpr = {
       val vparamss = constrVparamss match {
-        case (vparam :: _) :: _ if vparam.mods.is(Implicit) => // add a leading () to match class parameters
+        case (vparam :: _) :: _ if vparam.mods.is(ImplicitOrGiven) => // add a leading () to match class parameters
           Nil :: constrVparamss
         case _ =>
           constrVparamss
@@ -1177,7 +1177,7 @@ object desugar {
   def makeContextualFunction(formals: List[Type], body: Tree, isErased: Boolean)(implicit ctx: Context): Tree = {
     val mods = if (isErased) Given | Erased else Given
     val params = makeImplicitParameters(formals.map(TypeTree), mods)
-    new FunctionWithMods(params, body, Modifiers(Implicit | mods))
+    new FunctionWithMods(params, body, Modifiers(mods))
   }
 
   /** Add annotation to tree:
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -231,7 +231,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
         def valueParam(name: TermName, origInfo: Type): TermSymbol = {
           val maybeImplicit =
-            if (tp.isContextual) Implicit | Given
+            if (tp.isContextual) Given
             else if (tp.isImplicitMethod) Implicit
             else EmptyFlags
           val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -134,7 +134,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Implicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
 
-    case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit | Flags.Given)
+    case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Given)
 
     case class Erased()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Erased)
 
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -13,7 +13,7 @@ import Scopes._
 import Uniques._
 import ast.Trees._
 import ast.untpd
-import Flags.ImplicitOrImplied
+import Flags.ImplicitOrImpliedOrGiven
 import util.{FreshNameCreator, NoSource, SimpleIdentityMap, SourceFile}
 import typer.{Implicits, ImportInfo, Inliner, NamerContextOps, SearchHistory, SearchRoot, TypeAssigner, Typer}
 import Implicits.ContextualImplicits
@@ -214,7 +214,7 @@ object Contexts {
         implicitsCache = {
           val implicitRefs: List[ImplicitRef] =
             if (isClassDefContext)
-              try owner.thisType.implicitMembers(ImplicitOrImplied)
+              try owner.thisType.implicitMembers(ImplicitOrImpliedOrGiven)
               catch {
                 case ex: CyclicReference => Nil
               }
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -487,7 +487,7 @@ object Flags {
     HigherKinded.toCommonFlags | Param | ParamAccessor.toCommonFlags |
     Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
-    Extension.toCommonFlags | NonMember | Implicit | Implied | Permanent | Synthetic |
+    Extension.toCommonFlags | NonMember | Implicit | Given | Implied | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
@@ -589,8 +589,10 @@ object Flags {
   final val InlineOrProxy: FlagSet = Inline | InlineProxy
 
   final val ImplicitOrImplied = Implicit | Implied
+  final val ImplicitOrImpliedOrGiven = Implicit | Implied | Given
+  final val ImplicitOrGiven = Implicit | Given
 
-  final val ImplicitOrImpliedTerm = ImplicitOrImplied.toTermFlags
+  final val ImplicitOrImpliedOrGivenTerm = ImplicitOrImpliedOrGiven.toTermFlags
 
   /** Assumed to be pure */
   final val StableOrErased: FlagSet = StableRealizable | Erased
diff --git a/compiler/src/dotty/tools/dotc/core/Scopes.scala b/compiler/src/dotty/tools/dotc/core/Scopes.scala
@@ -409,7 +409,7 @@ object Scopes {
       var irefs = new mutable.ListBuffer[TermRef]
       var e = lastEntry
       while (e ne null) {
-        if (e.sym is ImplicitOrImplied) {
+        if (e.sym is ImplicitOrImpliedOrGiven) {
           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
@@ -1904,7 +1904,7 @@ object SymDenotations {
           if (keepOnly eq implicitFilter)
             if (this is Package) Iterator.empty
               // implicits in package objects are added by the overriding `memberNames` in `PackageClassDenotation`
-            else info.decls.iterator filter (_ is ImplicitOrImplied)
+            else info.decls.iterator filter (_ is ImplicitOrImpliedOrGiven)
           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
@@ -142,7 +142,7 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {
         }
       }
       // Give up and give generic errors.
-      else if (cycleSym.is(ImplicitOrImplied, butNot = Method) && cycleSym.owner.isTerm)
+      else if (cycleSym.is(ImplicitOrImpliedOrGiven, 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
@@ -794,7 +794,7 @@ object Types {
      */
     final def implicitMembers(kind: FlagSet)(implicit ctx: Context): List[TermRef] = track("implicitMembers") {
       memberDenots(implicitFilter,
-          (name, buf) => buf ++= member(name).altsWith(_.is(ImplicitOrImpliedTerm & kind)))
+          (name, buf) => buf ++= member(name).altsWith(_.is(ImplicitOrImpliedOrGivenTerm & kind)))
         .toList.map(d => TermRef(this, d.symbol.asTerm))
     }
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -936,7 +936,7 @@ object Parsers {
         case MATCH => matchType(EmptyTree, t)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
-          if (imods.is(Implicit) && !t.isInstanceOf[FunctionWithMods])
+          if (imods.is(ImplicitOrGiven) && !t.isInstanceOf[FunctionWithMods])
             syntaxError("Types with implicit keyword can only be function types `implicit (...) => ...`", implicitKwPos(start))
           if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
             syntaxError("Types with erased keyword can only be function types `erased (...) => ...`", implicitKwPos(start))
@@ -2218,7 +2218,7 @@ object Parsers {
         var initialMods = EmptyModifiers
         if (in.token == GIVEN) {
           in.nextToken()
-          initialMods |= Given | Implicit
+          initialMods |= Given
         }
         if (in.token == ERASED) {
           in.nextToken()
@@ -2247,16 +2247,15 @@ object Parsers {
               ofCaseClass = ofCaseClass,
               firstClause = firstClause,
               initialMods = initialMods)
-          val lastClause =
-            params.nonEmpty && params.head.mods.flags.is(Implicit, butNot = Given)
+          val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (if (lastClause) Nil else recur(firstClause = false, nparams + params.length, isContextual))
         }
         else if (isContextual) {
           val tps = commaSeparated(() => annotType())
           var counter = nparams
           def nextIdx = { counter += 1; counter }
           val paramFlags = if (ofClass) Private | Local | ParamAccessor else Param
-          val params = tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given | Implicit))
+          val params = tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
           params :: recur(firstClause = false, nparams + params.length, isContextual)
         }
         else Nil
@@ -2450,7 +2449,7 @@ object Parsers {
       if (in.token == THIS) {
         in.nextToken()
         val vparamss = paramClauses()
-        if (vparamss.isEmpty || vparamss.head.take(1).exists(_.mods.is(Implicit)))
+        if (vparamss.isEmpty || vparamss.head.take(1).exists(_.mods.is(ImplicitOrGiven)))
           in.token match {
             case LBRACKET   => syntaxError("no type parameters allowed here")
             case EOF        => incompleteInputError(AuxConstructorNeedsNonImplicitParameter())
@@ -2985,7 +2984,7 @@ object Parsers {
       }
     }
 
-    /** BlockStatSeq ::= { BlockStat semi } [ResultExpr]
+    /** BlockStatSeq ::= { BlockStat semi } [Expr]
      *  BlockStat    ::= Import
      *                 | Annotations [implicit] [lazy] Def
      *                 | Annotations LocalModifiers TmplDef
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(ImplicitOrImplied), sym.is(Lazy), sym.is(Macro), sym.isSuperAccessor)
+      sym.is(ImplicitOrImpliedOrGiven), sym.is(Lazy), sym.is(Macro), sym.isSuperAccessor)
   }
 
   def apiAnnotations(s: Symbol): List[api.Annotation] = {
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -663,7 +663,7 @@ trait Checking {
     }
 
   /** If `sym` is an implicit conversion, check that implicit conversions are enabled.
-   *  @pre  sym.is(Implicit)
+   *  @pre  sym.is(ImplicitOrGiven)
    */
   def checkImplicitConversionDefOK(sym: Symbol)(implicit ctx: Context): Unit = {
     def check(): Unit = {
@@ -694,7 +694,7 @@ trait Checking {
   def checkImplicitConversionUseOK(sym: Symbol, posd: Positioned)(implicit ctx: Context): Unit =
     if (sym.exists) {
       val conv =
-        if (sym.is(Implicit)) sym
+        if (sym.is(ImplicitOrGiven)) sym
         else {
           assert(sym.name == nme.apply)
           sym.owner
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -123,7 +123,7 @@ abstract class Lifter {
    *
    *  unless `pre` is idempotent.
    */
-  def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree = 
+  def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree =
     if (isIdempotentExpr(tree)) tree else lift(defs, tree)
 }
 
@@ -209,7 +209,7 @@ object EtaExpansion extends LiftImpure {
       else mt.paramInfos map TypeTree
     var paramFlag = Synthetic | Param
     if (mt.isContextual) paramFlag |= Given
-    if (mt.isImplicitMethod) paramFlag |= Implicit
+    else if (mt.isImplicitMethod) paramFlag |= Implicit
     val params = (mt.paramNames, paramTypes).zipped.map((name, tpe) =>
       ValDef(name, tpe, EmptyTree).withFlags(paramFlag).withSpan(tree.span.startPos))
     var ids: List[Tree] = mt.paramNames map (name => Ident(name).withSpan(tree.span.startPos))
@@ -219,7 +219,7 @@ object EtaExpansion extends LiftImpure {
     if (mt.isContextual) body.pushAttachment(ApplyGiven, ())
     if (!isLastApplication) body = PostfixOp(body, Ident(nme.WILDCARD))
     val fn =
-      if (mt.isContextual) new untpd.FunctionWithMods(params, body, Modifiers(Implicit | Given))
+      if (mt.isContextual) new untpd.FunctionWithMods(params, body, Modifiers(Given))
       else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit))
       else untpd.Function(params, body)
     if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn
diff --git a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -96,7 +96,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   }
 
   private def implicitFlag(implicit ctx: Context) =
-    if (importImplied || ctx.mode.is(Mode.FindHiddenImplicits)) ImplicitOrImplied
+    if (importImplied || ctx.mode.is(Mode.FindHiddenImplicits)) ImplicitOrImpliedOrGiven
     else Implicit
 
   /** The implicit references imported by this import clause */
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -125,7 +125,7 @@ trait NamerContextOps { this: Context =>
   /** if isConstructor, make sure it has one non-implicit parameter list */
   def normalizeIfConstructor(termParamss: List[List[Symbol]], isConstructor: Boolean): List[List[Symbol]] =
     if (isConstructor &&
-      (termParamss.isEmpty || termParamss.head.nonEmpty && (termParamss.head.head is Implicit)))
+      (termParamss.isEmpty || termParamss.head.nonEmpty && (termParamss.head.head is ImplicitOrGiven)))
       Nil :: termParamss
     else
       termParamss
@@ -749,7 +749,7 @@ class Namer { typer: Typer =>
 
   def missingType(sym: Symbol, modifier: String)(implicit ctx: Context): Unit = {
     ctx.error(s"${modifier}type of implicit definition needs to be given explicitly", sym.sourcePos)
-    sym.resetFlag(Implicit)
+    sym.resetFlag(ImplicitOrGiven)
   }
 
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
@@ -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(ImplicitOrImpliedOrGiven) != exp.impliedOnly) s"is ${if (exp.impliedOnly) "not " else ""}implied"
           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) &&
diff --git a/doc-tool/src/dotty/tools/dottydoc/core/DocImplicitsPhase.scala b/doc-tool/src/dotty/tools/dottydoc/core/DocImplicitsPhase.scala
@@ -14,7 +14,7 @@ class DocImplicitsPhase extends MiniPhase {
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
     if (
-      tree.symbol.is(Flags.Implicit)  && // has to have an implicit flag
+      tree.symbol.is(Flags.ImplicitOrImplied) && // has to have an implicit flag
       tree.symbol.owner.isStaticOwner && // owner has to be static (e.g. top-level `object`)
       tree.vparamss.length > 0        &&
       tree.vparamss(0).length == 1       // should only take one arg, since it has to be a transformation

Original file line number	Diff line number	Diff line change
`@@ -409,7 +409,7 @@ object Scopes {`
`409`	`409`	`var irefs = new mutable.ListBuffer[TermRef]`
`410`	`410`	`var e = lastEntry`
`411`	`411`	`while (e ne null) {`
`412`		`- if (e.sym is ImplicitOrImplied) {`
	`412`	`+ if (e.sym is ImplicitOrImpliedOrGiven) {`
`413`	`413`	`val d = e.sym.denot`
`414`	`414`	`irefs += TermRef(NoPrefix, d.symbol.asTerm).withDenot(d)`
`415`	`415`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`// Give up and give generic errors.`
`145`		`- else if (cycleSym.is(ImplicitOrImplied, butNot = Method) && cycleSym.owner.isTerm)`
	`145`	`+ else if (cycleSym.is(ImplicitOrImpliedOrGiven, butNot = Method) && cycleSym.owner.isTerm)`
`146`	`146`	`CyclicReferenceInvolvingImplicit(cycleSym)`
`147`	`147`	`else`
`148`	`148`	`CyclicReferenceInvolving(denot)`
Original file line number	Diff line number	Diff line change
`@@ -794,7 +794,7 @@ object Types {`
`794`	`794`	`*/`
`795`	`795`	`final def implicitMembers(kind: FlagSet)(implicit ctx: Context): List[TermRef] = track("implicitMembers") {`
`796`	`796`	`memberDenots(implicitFilter,`
`797`		`- (name, buf) => buf ++= member(name).altsWith(_.is(ImplicitOrImpliedTerm & kind)))`
	`797`	`+ (name, buf) => buf ++= member(name).altsWith(_.is(ImplicitOrImpliedOrGivenTerm & kind)))`
`798`	`798`	`.toList.map(d => TermRef(this, d.symbol.asTerm))`
`799`	`799`	`}`
`800`	`800`