Polishings in dotc, core, ast, parsing

Author: odersky

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

@@ -1810,6 +1810,8 @@ object desugar {
       case ext: ExtMethods =>
         Block(List(ext), Literal(Constant(())).withSpan(ext.span))
       case CapturingTypeTree(refs, parent) =>
+        // convert   `{refs} T`   to `T @retains refs`
+        //           `{refs}-> T` to `-> (T @retainsByName refs)`
         def annotate(annotName: TypeName, tp: Tree) =
           Annotated(tp, New(scalaDot(annotName), List(refs)))
         parent match

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

@@ -195,9 +195,11 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case arg => arg.typeOpt.widen.isRepeatedParam
   }
 
+  /** Is tree a type tree of the form `=> T` or (under -Ycc) `{refs}-> T`? */
   def isByNameType(tree: Tree)(using Context): Boolean =
     stripByNameType(tree) ne tree
 
+  /** Strip `=> T` to `T` and (under -Ycc) `{refs}-> T` to `T` */
   def stripByNameType(tree: Tree)(using Context): Tree = unsplice(tree) match
     case ByNameTypeTree(t1) => t1
     case untpd.CapturingTypeTree(_, parent) =>
@@ -398,10 +400,16 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     }
   }
 
+  /** Under -Ycc: A builder and extractor for `=> T`, which is an alias for `{*}-> T`.
+   *  Only trees of the form `=> T` are matched; trees written directly as `{*}-> T`
+   *  are ignored by the extractor.
+   */
   object ImpureByNameTypeTree:
+  
     def apply(tp: ByNameTypeTree)(using Context): untpd.CapturingTypeTree =
       untpd.CapturingTypeTree(
         Ident(nme.CAPTURE_ROOT).withSpan(tp.span.startPos) :: Nil, tp)
+
     def unapply(tp: Tree)(using Context): Option[ByNameTypeTree] = tp match
       case untpd.CapturingTypeTree(id @ Ident(nme.CAPTURE_ROOT) :: Nil, bntp: ByNameTypeTree)
       if id.span == bntp.span.startPos => Some(bntp)

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

@@ -165,7 +165,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
-    (if inferred then new InferredTypeTree() else untpd.TypeTree()).withType(tp)
+    (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
 
   def SingletonTypeTree(ref: Tree)(using Context): SingletonTypeTree =
     ta.assignType(untpd.SingletonTypeTree(ref), ref)

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

@@ -217,6 +217,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Infix()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Infix)
 
+    /** Used under -Ycc to mark impure function types `A => B` in `FunctionWithMods` */
     case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
   }
 
@@ -395,6 +396,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit src: SourceFile): JavaSeqLiteral = new JavaSeqLiteral(elems, elemtpt)
   def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit src: SourceFile): Inlined = new Inlined(call, bindings, expansion)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
+  def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
   def SingletonTypeTree(ref: Tree)(implicit src: SourceFile): SingletonTypeTree = new SingletonTypeTree(ref)
   def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit src: SourceFile): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
   def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit src: SourceFile): AppliedTypeTree = new AppliedTypeTree(tpt, args)

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -51,6 +51,8 @@ extension (tp: Type)
             case None => ann.tree.putAttachment(BoxedType, BoxedTypeCache())
             case _ =>
           ann.tree.attachment(BoxedType)(tp)
+    case tp: RealTypeBounds =>
+      tp.derivedTypeBounds(tp.lo.boxed, tp.hi.boxed)
     case _ =>
       tp
 
@@ -84,7 +86,7 @@ extension (tp: Type)
 
   /** Under -Ycc, map regular function type to impure function type
    */
-  def adaptFunctionType(using Context): Type = tp match
+  def adaptFunctionTypeUnderCC(using Context): Type = tp match
     case AppliedType(fn, args)
     if ctx.settings.Ycc.value && defn.isFunctionClass(fn.typeSymbol) =>
       val fname = fn.typeSymbol.name

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -575,6 +575,12 @@ object CaptureSet:
   def mapRefs(xs: Refs, tm: TypeMap, variance: Int)(using Context): CaptureSet =
     mapRefs(xs, extrapolateCaptureRef(_, tm, variance))
 
+  /** Return true iff
+   *   - arg1 is a TypeBounds >: CL T <: CH T of two capturing types with equal parents.
+   *   - arg2 is a capturing type CA U
+   *   - CH <: CA <: CL
+   *  In other words, we can unify CL, CH and CA.
+   */
   def subCapturesRange(arg1: TypeBounds, arg2: Type)(using Context): Boolean = arg1 match
     case TypeBounds(CapturingType(lo, loRefs), CapturingType(hi, hiRefs)) if lo =:= hi =>
       given VarState = VarState()

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

@@ -314,7 +314,7 @@ object Flags {
   /** A Scala 2x super accessor / an unpickled Scala 2.x class */
   val (SuperParamAliasOrScala2x @ _, SuperParamAlias @ _, Scala2x @ _) = newFlags(26, "<super-param-alias>", "<scala-2.x>")
 
-  /** A parameter with a default value / an impure untpd.Function type */
+  /** A parameter with a default value / an impure untpd.FunctionWithMods type */
   val (_, HasDefault @ _, Impure @ _) = newFlags(27, "<hasdefault>", "<{*}>")
 
   /** An extension method, or a collective extension instance */
@@ -405,7 +405,7 @@ object Flags {
   val (_, _, ChildrenQueried @ _) = newFlags(56, "<children-queried>")
 
   /** A module variable (Scala 2.x only)
-   *  (re-used as a capture checking flag in CheckCaptures)
+   *  (re-used as a flag for private parameter accessors in Recheck)
    */
   val (_, Scala2ModuleVar @ _, _) = newFlags(57, "<modulevar>")
 

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

@@ -192,23 +192,31 @@ object NamerOps:
     modcls.registeredCompanion = cls
 
   /** For secondary constructors, make it known in the context that their type parameters
-   *  are aliases of the class type parameters. This is done by (ab?)-using GADT constraints.
-   *  See pos/i941.scala
+   *  are aliases of the class type parameters.
+   *  @return  if `sym` is a secondary constructor, a fresh context that
+   *           contains GADT constraints linking the type parameters.
    */
   def linkConstructorParams(sym: Symbol)(using Context): Context =
     if sym.isConstructor && !sym.isPrimaryConstructor then
       sym.rawParamss match
         case (tparams @ (tparam :: _)) :: _ if tparam.isType =>
           val rhsCtx = ctx.fresh.setFreshGADTBounds
-          rhsCtx.gadt.addToConstraint(tparams)
-          tparams.lazyZip(sym.owner.typeParams).foreach { (psym, tparam) =>
-            val tr = tparam.typeRef
-            rhsCtx.gadt.addBound(psym, tr, isUpper = false)
-            rhsCtx.gadt.addBound(psym, tr, isUpper = true)
-          }
+          linkConstructorParams(sym, tparams, rhsCtx)
           rhsCtx
         case _ =>
           ctx
     else ctx
 
+  /** For secondary constructor `sym`, make it known in the given context `rhsCtx`
+   *  that their type parameters are aliases of the class type parameters. This is done
+   *  by (ab?)-using GADT constraints. See pos/i941.scala.
+   */
+  def linkConstructorParams(sym: Symbol, tparams: List[Symbol], rhsCtx: Context)(using Context): Unit =
+    rhsCtx.gadt.addToConstraint(tparams)
+    tparams.lazyZip(sym.owner.typeParams).foreach { (psym, tparam) =>
+      val tr = tparam.typeRef
+      rhsCtx.gadt.addBound(psym, tr, isUpper = false)
+      rhsCtx.gadt.addBound(psym, tr, isUpper = true)
+    }
+
 end NamerOps

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

@@ -282,7 +282,6 @@ object StdNames {
 // ----- Term names -----------------------------------------
 
     // Compiler-internal
-    val ANYname: N                  = "<anyname>"
     val CAPTURE_ROOT: N             = "*"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
@@ -350,7 +349,6 @@ object StdNames {
     val AppliedTypeTree: N      = "AppliedTypeTree"
     val ArrayAnnotArg: N        = "ArrayAnnotArg"
     val CAP: N                  = "CAP"
-    val ClassManifestFactory: N = "ClassManifestFactory"
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"
     val Eql: N                  = "Eql"

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

@@ -182,7 +182,7 @@ object Substituters:
 
   final class SubstSymMap(from: List[Symbol], to: List[Symbol])(using Context) extends DeepTypeMap, BiTypeMap {
     def apply(tp: Type): Type = substSym(tp, from, to, this)(using mapCtx)
-    def inverse(tp: Type) = tp.substSym(to, from)
+    def inverse(tp: Type) = tp.substSym(to, from) // implicitly requires that `to` contains no duplicates.
   }
 
   final class SubstThisMap(from: ClassSymbol, to: Type)(using Context) extends DeepTypeMap {