Merge branch 'scala:main' into hr/trigger-cc-tests

Author: hamzaremmal

MAINTENANCE.md

@@ -63,39 +63,48 @@ At the end of their supervision period, the supervisor reports to the team durin
 
 ## Maintenance List
 
-The following is the list of all the principal areas of the compiler and the core team members who are responsible for their maintenance:
+The following is the list of all the principal areas of the compiler and the internal team members who are responsible for their maintenance:
 
 ### Compiler
-- Parser: @odersky, @hamzaremmal
-- Typer: @odersky, @smarter, (@dwijnand), @noti0nal
+- Parser: @odersky, @hamzaremmal, @KacperFKorban
+- Typer: @odersky, @smarter, (@dwijnand), @noti0nal, @EugeneFlesselle, @KacperFKorban, @bracevac
 - Erasure: @smarter, @odersky
-- Enums: @bishabosha
-- Derivation & Mirrors: @bishabosha, (@dwijnand), @EugeneFlesselle
-- Export: @bishabosha, @odersky
-- Pattern Matching: @dwijnand, (@liufengyun), @sjrd
-- Inline: @nicolasstucki, @odersky, @hamzaremmal
-- Metaprogramming (Quotes, Reflect, Staging): @nicolasstucki, @jchyb, @hamzaremmal
-- Match types: @sjrd, @dwijnand, @Decel, @Linyxus
+- Enums: 
+- Derivation & Mirrors: (@dwijnand), @EugeneFlesselle
+- Export: @odersky
+- Pattern Matching: @dwijnand, @sjrd, @noti0na1
+- Inline: @odersky, @jchyb, @hamzaremmal, @EugeneFlesselle
+- Metaprogramming (Quotes, Reflect, Staging): @jchyb, @hamzaremmal
+- Match types: @sjrd, @dwijnand, @Linyxus, @EugeneFlesselle
 - GADT: @dwijnand, @Linyxus
-- Initialization checker: @olhotak, @liufengyun
-- Safe nulls: @noti0na1, @olhotak
-- Transforms: @szymon-rd, @sjrd, @odersky, @smarter
-- tailrec: @sjrd, @mbovel
+- Initialization checker: 
+- Transforms: @sjrd, @odersky, @smarter
+- Tailrec: @sjrd, @mbovel
 - JS backend: @sjrd
-- JVM backend: @sjrd
-- Java-compat: @smarter, @dwijnand
-- Capture checker: @odersky, @Linyxus
+- JVM backend: @sjrd, @hamzaremmal
+- Java-compat: @smarter, @dwijnand, @hamzaremmal
+- Extension Methods: @odersky, @dwijnand
+- Safe nulls (experimental): @noti0na1
+- Capture checker (experimental): @odersky, @Linyxus, @bracevac, @noti0na1
+- Modularity (experimental): @KacperFKorban
+- Named Tuples (experimental): @odersky
 
 ### Tooling
-- REPL: @dwijnand, @prolativ
+- REPL: @dwijnand
+- Runner/CLI: @Gedochao, (@tgodzik)
+- IDE: @tgodzik, (@kasiaMarek)
 - Scaladoc: @Florian3k
-- SemanticDB: @tanishiking
-- Coverage: @TheElectronWill
-- Linting (especially unused warnings) / Reporting UX: @szymon-rd
+- SemanticDB: @natsukagami, (@tanishiking)
+- Coverage: @KacperFKorban 
+- Linting (especially unused warnings) / Reporting UX: @KacperFKorban
+- Presentation Compiler: @rochala, @tgodzik, @kasiaMarek, @natsukagami 
+- Debug Adapter: @adpi2, (@tgodzik)
+- Scastie: @rochala
 
 ### Infrastructure
-- CI: @hamzaremmal
+- CI: @hamzaremmal, (@WojciechMazur)
 - Community Build: @hamzaremmal
 - Open Community Build: @WojciechMazur
-- Vulpix: @dwijnand, @prolativ
+- Vulpix: @dwijnand, @prolativ, @hamzaremmal
 - Benchmarks: @mbovel
+- Releases: @WojciechMazur, @prolativ

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

@@ -144,15 +144,15 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
   def allTermArguments(tree: Tree): List[Tree] = unsplice(tree) match {
     case Apply(fn, args) => allTermArguments(fn) ::: args
     case TypeApply(fn, args) => allTermArguments(fn)
-    case Block(_, expr) => allTermArguments(expr)
+    case Block(Nil, expr) => allTermArguments(expr)
     case _ => Nil
   }
 
   /** All type and term arguments of an application in a single flattened list */
   def allArguments(tree: Tree): List[Tree] = unsplice(tree) match {
     case Apply(fn, args) => allArguments(fn) ::: args
     case TypeApply(fn, args) => allArguments(fn) ::: args
-    case Block(_, expr) => allArguments(expr)
+    case Block(Nil, expr) => allArguments(expr)
     case _ => Nil
   }
 

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

@@ -527,10 +527,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeCapsOf(tp: RefTree)(using Context): Tree =
     TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
-  def makeCapsBound()(using Context): Tree =
-    makeRetaining(
+  // Capture set variable `[C^]` becomes: `[C >: CapSet <: CapSet^{cap}]`
+  def makeCapsBound()(using Context): TypeBoundsTree =
+    TypeBoundsTree(
       Select(scalaDot(nme.caps), tpnme.CapSet),
-      Nil, tpnme.retainsCap)
+      makeRetaining(
+        Select(scalaDot(nme.caps), tpnme.CapSet),
+        Nil, tpnme.retainsCap))
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)

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

@@ -44,6 +44,7 @@ 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?`
     }
     val arg = repeated(elems, TypeTree(defn.AnyType))
     New(symbol.typeRef, arg :: Nil)

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

@@ -93,12 +93,19 @@ trait CaptureRef extends TypeProxy, ValueType:
   final def invalidateCaches() =
     myCaptureSetRunId = NoRunId
 
-  /** x subsumes x
-   *   this subsumes this.f
+  /**  x subsumes x
+   *   x =:= y       ==>  x subsumes y
+   *   x subsumes y  ==>  x subsumes y.f
    *   x subsumes y  ==>  x* subsumes y, x subsumes y?
    *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
-   *   TODO: Document path cases
+   *   X = CapSet^cx, exists rx in cx, rx subsumes y     ==>  X subsumes y
+   *   Y = CapSet^cy, forall ry in cy, x subsumes ry     ==>  x subsumes Y
+   *   X: CapSet^c1...CapSet^c2, (CapSet^c1) subsumes y  ==>  X subsumes y
+   *   Y: CapSet^c1...CapSet^c2, x subsumes (CapSet^c2)  ==>  x subsumes Y
+   *   Contains[X, y]  ==>  X subsumes y
+   *
+   *   TODO: Document cases with more comments.
    */
   final def subsumes(y: CaptureRef)(using Context): Boolean =
 
@@ -135,14 +142,29 @@ trait CaptureRef extends TypeProxy, ValueType:
               case _ => false
           || viaInfo(y.info)(subsumingRefs(this, _))
         case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
+        case y: TypeRef if y.derivesFrom(defn.Caps_CapSet) =>
+          // The upper and lower bounds don't have to be in the form of `CapSet^{...}`.
+          // They can be other capture set variables, which are bounded by `CapSet`,
+          // like `def test[X^, Y^, Z >: X <: Y]`.
+          y.info match
+            case TypeBounds(_, hi: CaptureRef) => this.subsumes(hi)
+            case _ => y.captureSetOfInfo.elems.forall(this.subsumes)
+        case CapturingType(parent, refs) if parent.derivesFrom(defn.Caps_CapSet) =>
+          refs.elems.forall(this.subsumes)
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
         case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TermParamRef => subsumesExistentially(x, y)
-        case x: TypeRef if x.symbol.info.derivesFrom(defn.Caps_CapSet) =>
-          x.captureSetOfInfo.elems.exists(_.subsumes(y))
-        case x: TypeRef => assumedContainsOf(x).contains(y)
+        case x: TypeRef if assumedContainsOf(x).contains(y) => true
+        case x: TypeRef if x.derivesFrom(defn.Caps_CapSet) =>
+          x.info match
+            case TypeBounds(lo: CaptureRef, _) =>
+              lo.subsumes(y)
+            case _ =>
+              x.captureSetOfInfo.elems.exists(_.subsumes(y))
+        case CapturingType(parent, refs) if parent.derivesFrom(defn.Caps_CapSet) =>
+          refs.elems.exists(_.subsumes(y))
         case _ => false
   end subsumes
 

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

@@ -161,7 +161,9 @@ sealed abstract class CaptureSet extends Showable:
     def debugInfo(using Context) = i"$this accountsFor $x, which has capture set ${x.captureSetOfInfo}"
     def test(using Context) = reporting.trace(debugInfo):
       elems.exists(_.subsumes(x))
-      || !x.isMaxCapability && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
+      || !x.isMaxCapability
+        && !x.derivesFrom(defn.Caps_CapSet)
+        && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
     comparer match
       case comparer: ExplainingTypeComparer => comparer.traceIndented(debugInfo)(test)
       case _ => test

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

@@ -866,7 +866,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           if others.accountsFor(ref) then
             report.warning(em"redundant capture: $dom already accounts for $ref", pos)
 
-        if ref.captureSetOfInfo.elems.isEmpty && !ref.derivesFrom(defn.Caps_Capability) then
+        if ref.captureSetOfInfo.elems.isEmpty
+            && !ref.derivesFrom(defn.Caps_Capability)
+            && !ref.derivesFrom(defn.Caps_CapSet) then
           val deepStr = if ref.isReach then " deep" else ""
           report.error(em"$ref cannot be tracked since its$deepStr capture set is empty", pos)
         check(parent.captureSet, parent)

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -34,6 +34,7 @@ object Feature:
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
+  val namedTuples = experimental("namedTuples")
   val modularity = experimental("modularity")
   val betterMatchTypeExtractors = experimental("betterMatchTypeExtractors")
   val quotedPatternsWithPolymorphicFunctions = experimental("quotedPatternsWithPolymorphicFunctions")
@@ -65,6 +66,7 @@ object Feature:
     (pureFunctions, "Enable pure functions for capture checking"),
     (captureChecking, "Enable experimental capture checking"),
     (into, "Allow into modifier on parameter types"),
+    (namedTuples, "Allow named tuples"),
     (modularity, "Enable experimental modularity features"),
     (betterMatchTypeExtractors, "Enable better match type extractors"),
     (betterFors, "Enable improvements in `for` comprehensions")

compiler/src/dotty/tools/dotc/config/MigrationVersion.scala

@@ -26,7 +26,7 @@ enum MigrationVersion(val warnFrom: SourceVersion, val errorFrom: SourceVersion)
   case WithOperator extends MigrationVersion(`3.4`, future)
   case FunctionUnderscore extends MigrationVersion(`3.4`, future)
   case NonNamedArgumentInJavaAnnotation extends MigrationVersion(`3.6`, `3.6`)
-  case AmbiguousNamedTupleInfixApply extends MigrationVersion(`3.6`, never)
+  case AmbiguousNamedTupleSyntax extends MigrationVersion(`3.6`, future)
   case ImportWildcard extends MigrationVersion(future, future)
   case ImportRename extends MigrationVersion(future, future)
   case ParameterEnclosedByParenthesis extends MigrationVersion(future, future)

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

@@ -145,6 +145,15 @@ class TypeUtils:
       case defn.NamedTuple(_, _) => true
       case _ => false
 
+    def derivesFromNamedTuple(using Context): Boolean = self match
+      case defn.NamedTuple(_, _) => true
+      case tp: MatchType =>
+        tp.bound.derivesFromNamedTuple || tp.reduced.derivesFromNamedTuple
+      case tp: TypeProxy => tp.superType.derivesFromNamedTuple
+      case tp: AndType => tp.tp1.derivesFromNamedTuple || tp.tp2.derivesFromNamedTuple
+      case tp: OrType => tp.tp1.derivesFromNamedTuple && tp.tp2.derivesFromNamedTuple
+      case _ => false
+
     /** Drop all named elements in tuple type */
     def stripNamedTuple(using Context): Type = self.normalized.dealias match
       case defn.NamedTuple(_, vals) =>