Use a specific NameKind for context bounds

There are various places in the compiler and assorted tools where we assume
that an EvidenceParamName is the name of a context bound, but in practice we
also used the same NameKind in other cases such as for inferred contextual
functions. This commit cleans things up by replacing EvidenceParamName by:
- ContextBoundParamName
- ContextFunctionParamName
- CanThrowEvidenceParamName
- and the existing WildcardParamName

Note that Scala 2 also uses "evidence$" prefixes to represent context bounds,
this is why some pretty-printing code that aims to resugar context bounds
coming from both Scala 2 and 3 does a syntactic check for
`ContextBoundParamName.separator` instead of a semantic check on the NameKind
itself, this could perhaps be handled in a nicer way using unmangle in the
Scala2Unpickler.

Author: smarter

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

@@ -7,7 +7,7 @@ import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags
 import Symbols._, StdNames._, Trees._, ContextOps._
 import Decorators._, transform.SymUtils._
 import Annotations.Annotation
-import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName, WildcardParamName}
+import NameKinds.{UniqueName, ContextBoundParamName, ContextFunctionParamName, DefaultGetterName, WildcardParamName}
 import typer.{Namer, Checking}
 import util.{Property, SourceFile, SourcePosition, Chars}
 import config.Feature.{sourceVersion, migrateTo3, enabled}
@@ -203,10 +203,14 @@ object desugar {
     else vdef1
   end valDef
 
-  def makeImplicitParameters(tpts: List[Tree], implicitFlag: FlagSet, forPrimaryConstructor: Boolean = false)(using Context): List[ValDef] =
-    for (tpt <- tpts) yield {
+  def makeImplicitParameters(
+      tpts: List[Tree], implicitFlag: FlagSet,
+      mkParamName: () => TermName,
+      forPrimaryConstructor: Boolean = false
+  )(using Context): List[ValDef] =
+    for (tpt, i) <- tpts.zipWithIndex yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) LocalParamAccessor else Param
-       val epname = EvidenceParamName.fresh()
+       val epname = mkParamName()
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | implicitFlag)
     }
 
@@ -244,7 +248,9 @@ object desugar {
       case ContextBounds(tbounds, cxbounds) =>
         val iflag = if sourceVersion.isAtLeast(`future`) then Given else Implicit
         evidenceParamBuf ++= makeImplicitParameters(
-          cxbounds, iflag, forPrimaryConstructor = isPrimaryConstructor)
+          cxbounds, iflag,
+          mkParamName = () => ContextBoundParamName.fresh(),
+          forPrimaryConstructor = isPrimaryConstructor)
         tbounds
       case LambdaTypeTree(tparams, body) =>
         cpy.LambdaTypeTree(rhs)(tparams, desugarContextBounds(body))
@@ -406,11 +412,11 @@ object desugar {
             meth.paramss :+ evidenceParams
         cpy.DefDef(meth)(paramss = paramss1)
 
-  /** The implicit evidence parameters of `meth`, as generated by `desugar.defDef` */
+  /** The parameters generated from the contextual bounds of `meth`, as generated by `desugar.defDef` */
   private def evidenceParams(meth: DefDef)(using Context): List[ValDef] =
     meth.paramss.reverse match {
       case ValDefs(vparams @ (vparam :: _)) :: _ if vparam.mods.isOneOf(GivenOrImplicit) =>
-        vparams.takeWhile(_.name.is(EvidenceParamName))
+        vparams.takeWhile(_.name.is(ContextBoundParamName))
       case _ =>
         Nil
     }
@@ -1585,7 +1591,7 @@ object desugar {
 
   def makeContextualFunction(formals: List[Tree], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
     val mods = Given
-    val params = makeImplicitParameters(formals, mods)
+    val params = makeImplicitParameters(formals, mods, mkParamName = () => ContextFunctionParamName.fresh())
     FunctionWithMods(params, body, Modifiers(mods), erasedParams)
   }
 

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

@@ -278,9 +278,31 @@ object NameKinds {
       if (underlying.isEmpty) "$" + info.num + "$" else super.mkString(underlying, info)
   }
 
+  /** The name of the term parameter generated for a context bound:
+   *
+   *      def foo[T: A](...): ...
+   *
+   *  becomes:
+   *
+   *      def foo[T](...)(using evidence$1: A[T]): ...
+   *
+   *  The "evidence$" prefix is a convention copied from Scala 2.
+   */
+  val ContextBoundParamName: UniqueNameKind    = new UniqueNameKind("evidence$")
+
+  /** The name of an inferred contextual function parameter:
+   *
+   *      val x: A ?=> B = b
+   *
+   *  becomes:
+   *
+   *      val x: A ?=> B = (contextual$1: A) ?=> b
+   */
+  val ContextFunctionParamName: UniqueNameKind = new UniqueNameKind("contextual$")
+
   /** Other unique names */
+  val CanThrowEvidenceName: UniqueNameKind   = new UniqueNameKind("canThrow$")
   val TempResultName: UniqueNameKind         = new UniqueNameKind("ev$")
-  val EvidenceParamName: UniqueNameKind      = new UniqueNameKind("evidence$")
   val DepParamName: UniqueNameKind           = new UniqueNameKind("(param)")
   val LazyImplicitName: UniqueNameKind       = new UniqueNameKind("$_lazy_implicit_$")
   val LazyLocalName: UniqueNameKind          = new UniqueNameKind("$lzy")

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -216,7 +216,8 @@ object Scala3:
 
       def isEmptyNumbered: Boolean =
         !name.is(NameKinds.WildcardParamName)
-        && !name.is(NameKinds.EvidenceParamName)
+        && !name.is(NameKinds.ContextBoundParamName)
+        && !name.is(NameKinds.ContextFunctionParamName)
         && { name match
           case NameKinds.AnyNumberedName(nme.EMPTY, _) => true
           case _                                       => false

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

@@ -13,7 +13,7 @@ import Contexts._
 import Types._
 import Flags._
 import Mode.ImplicitsEnabled
-import NameKinds.{LazyImplicitName, EvidenceParamName}
+import NameKinds.{LazyImplicitName, ContextBoundParamName}
 import Symbols._
 import Types._
 import Decorators._
@@ -993,7 +993,7 @@ trait Implicits:
         def addendum = if (qt1 eq qt) "" else (i"\nWhere $qt is an alias of: $qt1")
         i"parameter of ${qual.tpe.widen}$addendum"
       case _ =>
-        i"${ if paramName.is(EvidenceParamName) then "an implicit parameter"
+        i"${ if paramName.is(ContextBoundParamName) then "a context parameter"
              else s"parameter $paramName" } of $methodStr"
     }
 

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

@@ -1734,8 +1734,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           checkInInlineContext("summonFrom", tree.srcPos)
           val cases1 = tree.cases.mapconserve {
             case cdef @ CaseDef(pat @ Typed(Ident(nme.WILDCARD), _), _, _) =>
-              // case _ : T  -->  case evidence$n : T
-              cpy.CaseDef(cdef)(pat = untpd.Bind(EvidenceParamName.fresh(), pat))
+              // case _ : T  -->  case _$n : T
+              cpy.CaseDef(cdef)(pat = untpd.Bind(WildcardParamName.fresh(), pat))
             case cdef => cdef
           }
           typedMatchFinish(tree, tpd.EmptyTree, defn.ImplicitScrutineeTypeRef, cases1, pt)
@@ -2010,7 +2010,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   def addCanThrowCapabilities(expr: untpd.Tree, cases: List[CaseDef])(using Context): untpd.Tree =
     def makeCanThrow(tp: Type): untpd.Tree =
       untpd.ValDef(
-          EvidenceParamName.fresh(),
+          CanThrowEvidenceName.fresh(),
           untpd.TypeTree(defn.CanThrowClass.typeRef.appliedTo(tp)),
           untpd.ref(defn.Compiletime_erasedValue))
         .withFlags(Given | Final | Erased)
@@ -3756,7 +3756,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           else tree
         else if wtp.isContextualMethod then
           def isContextBoundParams = wtp.stripPoly match
-            case MethodType(EvidenceParamName(_) :: _) => true
+            case MethodType(ContextBoundParamName(_) :: _) => true
             case _ => false
           if sourceVersion == `future-migration` && isContextBoundParams && pt.args.nonEmpty
           then // Under future-migration, don't infer implicit arguments yet for parameters

compiler/src/dotty/tools/dotc/util/Signatures.scala

@@ -407,7 +407,7 @@ object Signatures {
       (params :: rest)
 
     def isSyntheticEvidence(name: String) =
-      if !name.startsWith(NameKinds.EvidenceParamName.separator) then false else
+      if !name.startsWith(NameKinds.ContextBoundParamName.separator) then false else
         symbol.paramSymss.flatten.find(_.name.show == name).exists(_.flags.is(Flags.Implicit))
 
     denot.info.stripPoly match

presentation-compiler/src/main/dotty/tools/pc/completions/ScaladocCompletions.scala

@@ -112,7 +112,7 @@ object ScaladocCompletions:
           defdef.trailingParamss.flatten.collect {
             case param
                 if !param.symbol.isOneOf(Synthetic) &&
-                  !param.name.is(EvidenceParamName) &&
+                  !param.name.is(ContextBoundParamName) &&
                   param.symbol != extensionParam =>
               param.name.show
           }
@@ -121,7 +121,7 @@ object ScaladocCompletions:
             case param
                 if !param.is(Synthetic) &&
                   !param.isTypeParam &&
-                  !param.name.is(EvidenceParamName) =>
+                  !param.name.is(ContextBoundParamName) =>
               param.name.show
           }
         case other =>

presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala

@@ -9,7 +9,7 @@ import scala.meta.pc.SymbolSearch
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Flags.*
-import dotty.tools.dotc.core.NameKinds.EvidenceParamName
+import dotty.tools.dotc.core.NameKinds.ContextBoundParamName
 import dotty.tools.dotc.core.NameOps.*
 import dotty.tools.dotc.core.Names
 import dotty.tools.dotc.core.Names.Name
@@ -270,7 +270,7 @@ class ShortenedTypePrinter(
 
     lazy val implicitEvidenceParams: Set[Symbol] =
       implicitParams
-        .filter(p => p.name.toString.startsWith(EvidenceParamName.separator))
+        .filter(p => p.name.toString.startsWith(ContextBoundParamName.separator))
         .toSet
 
     lazy val implicitEvidencesByTypeParam: Map[Symbol, List[String]] =

scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala

@@ -578,7 +578,7 @@ trait ClassLikeSupport:
     val baseTypeRepr = typeForClass(c).memberType(symbol)
 
     def isSyntheticEvidence(name: String) =
-      if !name.startsWith(NameKinds.EvidenceParamName.separator) then false else
+      if !name.startsWith(NameKinds.ContextBoundParamName.separator) then false else
         // This assumes that every parameter that starts with `evidence$` and is implicit is generated by compiler to desugar context bound.
         // Howrever, this is just a heuristic, so
         // `def foo[A](evidence$1: ClassTag[A]) = 1`

tests/neg/i11350.check

@@ -1,15 +1,15 @@
 -- [E081] Type Error: tests/neg/i11350.scala:1:39 ----------------------------------------------------------------------
 1 |class A1[T](action: A1[T] ?=> String = "") // error
   |                                       ^
-  |                                       Could not infer type for parameter evidence$1 of anonymous function
+  |                                       Could not infer type for parameter contextual$1 of anonymous function
   |
   |                                       Partially inferred type for the parameter: A1[<?>]
   |
   |                                       Expected type for the whole anonymous function: (A1[<?>]) ?=> String
 -- [E081] Type Error: tests/neg/i11350.scala:2:39 ----------------------------------------------------------------------
 2 |class A2[T](action: A1[T] ?=> String = summon[A1[T]]) // error
   |                                       ^
-  |                                       Could not infer type for parameter evidence$2 of anonymous function
+  |                                       Could not infer type for parameter contextual$2 of anonymous function
   |
   |                                       Partially inferred type for the parameter: A1[<?>]
   |