Address review comments

[Cherry-picked 4f28d8a]

Author: odersky

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

@@ -234,7 +234,7 @@ object desugar {
    *                       of the same method.
    *  @param evidenceFlags The flags to use for evidence definitions
    *  @param freshName     A function to generate fresh names for evidence definitions
-   *  @param allParams     If `tdef` is a type paramter, all parameters of the owning method,
+   *  @param allParamss    If `tdef` is a type paramter, all parameters of the owning method,
    *                       otherwise the empty list.
    */
   private def desugarContextBounds(
@@ -246,29 +246,31 @@ object desugar {
 
     val evidenceNames = mutable.ListBuffer[TermName]()
 
-    def desugarRhs(rhs: Tree): Tree = rhs match
-      case ContextBounds(tbounds, cxbounds) =>
+    def desugarRHS(rhs: Tree): Tree = rhs match
+      case ContextBounds(tbounds, ctxbounds) =>
         val isMember = evidenceFlags.isAllOf(DeferredGivenFlags)
-        for bound <- cxbounds do
+        for bound <- ctxbounds do
           val evidenceName = bound match
             case ContextBoundTypeTree(_, _, ownName) if !ownName.isEmpty =>
               ownName // if there is an explicitly given name, use it.
-            case _ if Config.nameSingleContextBounds && !isMember
-                && cxbounds.tail.isEmpty && Feature.enabled(Feature.modularity) =>
-              tdef.name.toTermName
             case _ =>
-              freshName(bound)
+              if Config.nameSingleContextBounds
+                && !isMember
+                && ctxbounds.tail.isEmpty
+                && Feature.enabled(Feature.modularity)
+              then tdef.name.toTermName
+              else freshName(bound)
           evidenceNames += evidenceName
           val evidenceParam = ValDef(evidenceName, bound, EmptyTree).withFlags(evidenceFlags)
           evidenceParam.pushAttachment(ContextBoundParam, ())
           evidenceBuf += evidenceParam
         tbounds
       case LambdaTypeTree(tparams, body) =>
-        cpy.LambdaTypeTree(rhs)(tparams, desugarRhs(body))
+        cpy.LambdaTypeTree(rhs)(tparams, desugarRHS(body))
       case _ =>
         rhs
 
-    val tdef1 = cpy.TypeDef(tdef)(rhs = desugarRhs(tdef.rhs))
+    val tdef1 = cpy.TypeDef(tdef)(rhs = desugarRHS(tdef.rhs))
     // Under x.modularity, if there was a context bound, and `tdef`s name as a term name is
     // neither a name of an existing parameter nor a name of generated evidence for
     // the same method, add a WitnessAnnotation with all generated evidence names to `tdef`.
@@ -695,10 +697,10 @@ object desugar {
       case _ => false
     }
 
-    def isRepeated(tree: Tree): Boolean = stripByNameType(tree) match {
+    /** Is this a repeated argument x* (using a spread operator)? */
+    def isRepeated(tree: Tree): Boolean = stripByNameType(tree) match
       case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
       case _ => false
-    }
 
     def appliedRef(tycon: Tree, tparams: List[TypeDef] = constrTparams, widenHK: Boolean = false) = {
       val targs = for (tparam <- tparams) yield {
@@ -1218,7 +1220,7 @@ object desugar {
 
   /** Extract a synthesized given name from a type tree. This is used for
    *  both anonymous givens and (under x.modularity) deferred givens.
-   *  @param followArgs   If true include argument types in the name
+   *  @param followArgs   if true include argument types in the name
    */
   private class NameExtractor(followArgs: Boolean) extends UntypedTreeAccumulator[String] {
     private def extractArgs(args: List[Tree])(using Context): String =

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

@@ -394,22 +394,16 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
         ))
 
     def unapply(tree: Tree)(using Context): Option[List[TermName]] =
-      def isWitnessNames(tp: Type) = tp match
-        case tp: TypeRef =>
-          tp.name == tpnme.WitnessNames && tp.symbol == defn.WitnessNamesAnnot
-        case _ =>
-          false
       unsplice(tree) match
-        case Apply(
-            Select(New(tpt: tpd.TypeTree), nme.CONSTRUCTOR),
-            SeqLiteral(elems, _) :: Nil
-          ) if isWitnessNames(tpt.tpe) =>
-          Some:
-            elems.map:
-              case Literal(Constant(str: String)) =>
-                ContextBoundParamName.unmangle(str.toTermName.asSimpleName)
-        case _ =>
-          None
+        case Apply(Select(New(tpt: tpd.TypeTree), nme.CONSTRUCTOR), SeqLiteral(elems, _) :: Nil) =>
+          tpt.tpe match
+            case tp: TypeRef if tp.name == tpnme.WitnessNames && tp.symbol == defn.WitnessNamesAnnot =>
+              Some:
+                elems.map:
+                  case Literal(Constant(str: String)) =>
+                    ContextBoundParamName.unmangle(str.toTermName.asSimpleName)
+            case _ => None
+        case _ => None
   end WitnessNamesAnnot
 }
 

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

@@ -573,7 +573,7 @@ object Flags {
   val DeferredOrLazyOrMethod: FlagSet        = Deferred | Lazy | Method
   val DeferredOrTermParamOrAccessor: FlagSet = Deferred | ParamAccessor | TermParam           // term symbols without right-hand sides
   val DeferredOrTypeParam: FlagSet           = Deferred | TypeParam                           // type symbols without right-hand sides
-  val DeferredGivenFlags                     = Deferred | Given | HasDefault
+  val DeferredGivenFlags: FlagSet            = Deferred | Given | HasDefault
   val EnumValue: FlagSet                     = Enum | StableRealizable                        // A Scala enum value
   val FinalOrInline: FlagSet                 = Final | Inline
   val FinalOrModuleClass: FlagSet            = Final | ModuleClass                            // A module class or a final class

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

@@ -262,7 +262,7 @@ object NamerOps:
    *  bound that defines a set of witnesses with names `witnessNames`.
    *
    *  @param params  If `tsym` is a type parameter, a list of parameter symbols
-   *                 that include all witnesses, otherwise the empty list.
+   *                 that includes all witnesses, otherwise the empty list.
    *
    *  The context-bound companion has as name the name of `tsym` translated to
    *  a term name. We create a synthetic val of the form

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

@@ -1655,7 +1655,7 @@ object Types extends TypeUtils {
      *
      *    P { ... type T = / += / -= U ... } # T
      *
-     *  to just U. Analogously, `P { val x: S} # x` is reduced tp `S` if `S`
+     *  to just U. Analogously, `P { val x: S} # x` is reduced to `S` if `S`
      *  is a singleton type.
      *
      *  Does not perform the reduction if the resulting type would contain
@@ -5050,14 +5050,14 @@ object Types extends TypeUtils {
      *  or if it has as an upper bound a precise TypeVar.
      */
     def isPrecise(using Context) =
-      precise
-      || {
-        val constr = ctx.typerState.constraint
-        constr.upper(origin).exists: tparam =>
-          constr.typeVarOfParam(tparam) match
-            case tvar: TypeVar => tvar.precise
-            case _ => false
-      }
+      precise || hasPreciseUpperBound
+
+    private def hasPreciseUpperBound(using Context) =
+      val constr = ctx.typerState.constraint
+      constr.upper(origin).exists: tparam =>
+        constr.typeVarOfParam(tparam) match
+          case tvar: TypeVar => tvar.precise
+          case _ => false
 
     /** The policy used for widening singletons or unions when instantiating
      *  this variable in the current context.

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3552,9 +3552,10 @@ object Parsers {
                     !impliedMods.is(Given)
                     || startParamTokens.contains(in.token)
                     || isIdent
-                        && (in.name == nme.inline
-                           || in.name == nme.tracked && in.featureEnabled(Feature.modularity)
-                           || in.lookahead.isColon)
+                        && (in.name == nme.inline    // inline starts a name binding
+                           || in.name == nme.tracked // tracked starts a name binding under x.modularity
+                              && in.featureEnabled(Feature.modularity)
+                           || in.lookahead.isColon)  // a following `:` starts a name binding
                   (mods, paramsAreNamed)
               val params =
                 if paramsAreNamed then commaSeparated(() => param())

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

@@ -1860,7 +1860,7 @@ class Namer { typer: Typer =>
         for case WitnessNamesAnnot(ws) <- tdef.mods.annotations do
           witnessNamesOfParam(tdef) = ws
 
-    /** Is each name in `wnames` defined spmewhere in the longest prefix of all `params`
+    /** Is each name in `wnames` defined somewhere in the longest prefix of all `params`
      *  that have been typed ahead (i.e. that carry the TypedAhead attachment)?
      */
     def allParamsSeen(wnames: List[TermName], params: List[MemberDef]) =
@@ -1919,7 +1919,7 @@ class Namer { typer: Typer =>
       && param.hasAttachment(ContextBoundParam)
       && sym.info.memberNames(abstractTypeNameFilter).nonEmpty
 
-    /** Set every context bound evidence parameter of a class to be tracked,
+    /** Under x.modularity, set every context bound evidence parameter of a class to be tracked,
      *  provided it has a type that has an abstract type member. Reset private and local flags
      *  so that the parameter becomes a `val`.
      */

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

@@ -888,7 +888,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case (tp1: TermRef, tp2: TermRef) =>
           if tp1.info.isSingleton && (tp1 frozen_=:= tp2) then 1
           else compare(tp1, tp2, preferGeneral = false)
-        case (tp1: TermRef, _) => 1 // should not happen, but prefer TermRefs over othersver others
+        case (tp1: TermRef, _) => 1 // should not happen, but prefer TermRefs over others
         case (_, tp2: TermRef) => -1
         case _ => 0
 
@@ -4588,7 +4588,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           cpy.Ident(qual)(qual.symbol.name.sourceModuleName.toTypeName)
         case _ =>
           errorTree(tree, em"cannot convert from $tree to an instance creation expression")
-      val tycon = ctorResultType.underlyingClassRef(refinementOK = true)
+      val tycon = ctorResultType.underlyingClassRef(refinementOK = Feature.enabled(modularity))
       typed(
         untpd.Select(
           untpd.New(untpd.TypedSplice(tpt.withType(tycon))),

docs/_docs/internals/syntax.md

@@ -191,7 +191,7 @@ MatchType         ::=  InfixType `match` <<< TypeCaseClauses >>>
 InfixType         ::=  RefinedType {id [nl] RefinedType}                        InfixOp(t1, op, t2)
 RefinedType       ::=  AnnotType {[nl] Refinement}                              RefinedTypeTree(t, ds)
 AnnotType         ::=  SimpleType {Annotation}                                  Annotated(t, annot)
-AnnotType1         ::=  SimpleType1 {Annotation}                                Annotated(t, annot)
+AnnotType1        ::=  SimpleType1 {Annotation}                                 Annotated(t, annot)
 
 SimpleType        ::=  SimpleLiteral                                            SingletonTypeTree(l)
                     |  ‘?’ TypeBounds

library/src/scala/annotation/internal/WitnessNames.scala

@@ -11,7 +11,7 @@ package internal
  *
  *  2. During Namer or Unpickling, when encountering a type declaration A with
  *  a WitnessNames(n_1, ... , n_k) annotation, create a CB companion `val A` with
- *  rtype `<context-bound-companion>`[ref_1 | ... | ref_k] where ref_i is a TermRef
+ *  type `<context-bound-companion>`[ref_1 | ... | ref_k] where ref_i is a TermRef
  *  with the same prefix as A and name n_i. Except, don't do this if the type in
  *  question is a type parameter and there is already a term parameter with name A
  *  defined for the same method.
@@ -20,7 +20,7 @@ package internal
  *
  *     type `<context-bound-companion>`[-Refs]
  *
- *  The context bound companion's variance is negative, so that unons in the
+ *  The context bound companion's variance is negative, so that unions in the
  *  arguments are joined when encountering multiple definfitions and forming a glb.
  *
  *  3. Add a special case for typing a selection A.m on a value A of type