Separation checking for product types (#22539)

This is based on #22588 and contains changes to make product types
containing fresh entities work (at least in simple cases). There's a
neat combination with both path capabilities and reach capabilities
which makes this work.

In short, if we have 
```scala
class Ref { var current: Int }
case class Pair[+A, +B](fst: A, snd: B)
```
then we can form a `Pair[Ref^, Ref^]`:
```scala
val r1 = Ref()
val r2 = Ref()
val p_exact: Pair[Ref^{r1}, Ref^{r2}] = Pair(r1, r2)
val p:  Pair[Ref^, Ref^] = p_exact
```
And if `p` has this type, then we can also take it apart:
```scala
val x = p.fst
val y = p.snd
```
With types added, this is
```scala
val x: Ref^{p.fst*} = p.fst
val y: Ref^{p.snd*} = p.snd
```
That is, we can get at the position of the boxed first element with
`p.fst` and we can access what's in the box via `p.fst*`.
Furthermore, `p.fst*` is known to be separate from `p.snd*`, so this
means we can form another pair from them:
```scala
val p2: Pair[Ref^, Ref^] = Pair(x, y)
```
In short, separation is preserved by forming products and taking them
apart. It took quite a bit of work to get there.

Author: odersky

.jvmopts

@@ -1,5 +1,5 @@
 -Xss1m
--Xms512m
--Xmx4096m
+-Xms1024m
+-Xmx8192m
 -XX:MaxInlineLevel=35
 -XX:ReservedCodeCacheSize=512m

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -285,7 +285,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAcce
     // tests/run/serialize.scala and https://github.com/typelevel/cats-effect/pull/2360).
     val privateFlag = !sym.isClass && (sym.is(Private) || (sym.isPrimaryConstructor && sym.owner.isTopLevelModuleClass))
 
-    val finalFlag = sym.is(Final) && !toDenot(sym).isClassConstructor && !sym.is(Mutable, butNot = Accessor) && !sym.enclosingClass.is(Trait)
+    val finalFlag = sym.is(Final) && !toDenot(sym).isClassConstructor && !sym.isMutableVar && !sym.enclosingClass.is(Trait)
 
     import asm.Opcodes.*
     import GenBCodeOps.addFlagIf

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

@@ -2262,6 +2262,8 @@ object desugar {
               New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
         else if op.name == nme.CC_REACH then
           Apply(ref(defn.Caps_reachCapability), t :: Nil)
+        else if op.name == nme.CC_READONLY then
+          Apply(ref(defn.Caps_readOnlyCapability), t :: Nil)
         else
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
           Select(t, op.name)

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

@@ -759,7 +759,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    */
   def isVariableOrGetter(tree: Tree)(using Context): Boolean = {
     def sym = tree.symbol
-    def isVar = sym.is(Mutable)
+    def isVar = sym.isMutableVarOrAccessor
     def isGetter =
       mayBeVarGetter(sym) && sym.owner.info.member(sym.name.asTermName.setterName).exists
 

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

@@ -206,6 +206,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Var()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Mutable)
 
+    case class Mut()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Mutable)
+
     case class Implicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
 
     case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Given)
@@ -332,6 +334,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     def isEnumCase: Boolean = isEnum && is(Case)
     def isEnumClass: Boolean = isEnum && !is(Case)
+    def isMutableVar: Boolean = is(Mutable) && mods.exists(_.isInstanceOf[Mod.Var])
   }
 
   @sharable val EmptyModifiers: Modifiers = Modifiers()

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

@@ -42,7 +42,8 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
       case cr: TermRef => ref(cr)
       case cr: TermParamRef => untpd.Ident(cr.paramName).withType(cr)
       case cr: ThisType => This(cr.cls)
-      // TODO: Will crash if the type is an annotated type, for example `cap?`
+      case root(_) => ref(root.cap)
+      // TODO: Will crash if the type is an annotated type, for example `cap.rd`
     }
     val arg = repeated(elems, TypeTree(defn.AnyType))
     New(symbol.typeRef, arg :: Nil)