Merge pull request #6497 from dotty-staging/simplify-implicit-flags

Simplify implicit flags

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -173,17 +173,17 @@ object desugar {
         vparamss = (setterParam :: Nil) :: Nil,
         tpt      = TypeTree(defn.UnitType),
         rhs      = setterRhs
-      ).withMods((mods | Accessor) &~ (CaseAccessor | Implicit | Given | Lazy))
+      ).withMods((mods | Accessor) &~ (CaseAccessor | ImplicitOrGiven | Lazy))
       Thicket(vdef, setter)
     }
     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.,
@@ -219,7 +219,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))
@@ -322,7 +322,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
@@ -333,7 +333,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
@@ -344,7 +344,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 = {
@@ -412,7 +412,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
       }
@@ -507,18 +507,17 @@ 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
       }
       val nu = (makeNew(classTypeRef) /: vparamss) { (nu, vparams) =>
         val app = Apply(nu, vparams.map(refOfDef))
         vparams match {
-          case vparam :: _ if vparam.mods.is(Given) => app.pushAttachment(ApplyGiven, ())
-          case _ =>
+          case vparam :: _ if vparam.mods.is(Given) => app.setGivenApply()
+          case _ => app
         }
-        app
       }
       ensureApplied(nu)
     }
@@ -1196,7 +1195,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:

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -436,7 +436,8 @@ object Trees {
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = Apply[T]
 
-    def isContextual = getAttachment(untpd.ApplyGiven).nonEmpty
+    def isGivenApply = getAttachment(untpd.ApplyGiven).nonEmpty
+    def setGivenApply() = { pushAttachment(untpd.ApplyGiven, ()); this }
   }
 
   /** fun[args] */

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.isContextualMethod) Given
             else if (tp.isImplicitMethod) Implicit
             else EmptyFlags
           val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -143,7 +143,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)
 

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
               }

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

@@ -128,10 +128,10 @@ class Definitions {
           enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
         }
         val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
-        val methodType = MethodType.maker(
+        val methodType = MethodType.companion(
           isJava = false,
-          isImplicit = name.isImplicitFunction,
           isContextual = name.isImplicitFunction,
+          isImplicit = false,
           isErased = name.isErasedFunction)
         decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
         denot.info =

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

@@ -624,8 +624,8 @@ object Denotations {
           tp2 match {
             case tp2: PolyType =>
               tp1
-            case tp2: MethodType if ctx.typeComparer.matchingMethodParams(tp1, tp2) &&
-                tp1.isImplicitMethod == tp2.isImplicitMethod =>
+            case tp2: MethodType
+            if ctx.typeComparer.matchingMethodParams(tp1, tp2) && (tp1.companion eq tp2.companion) =>
               tp1.derivedLambdaType(
                 mergeParamNames(tp1, tp2),
                 tp1.paramInfos,
@@ -683,8 +683,7 @@ object Denotations {
       case tp1: MethodType =>
         tp2 match {
           case tp2: MethodType
-          if ctx.typeComparer.matchingMethodParams(tp1, tp2) &&
-              tp1.isImplicitMethod == tp2.isImplicitMethod =>
+          if ctx.typeComparer.matchingMethodParams(tp1, tp2) && (tp1.companion eq tp2.companion) =>
             tp1.derivedLambdaType(
               mergeParamNames(tp1, tp2),
               tp1.paramInfos,

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

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)
         }

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