Polishings mostly in typer

Author: odersky

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -196,7 +196,6 @@ private class ExtractAPICollector(using Context) extends ThunkHolder {
   private val byNameMarker = marker("ByName")
   private val matchMarker = marker("Match")
   private val superMarker = marker("Super")
-  private val retainsMarker = marker("Retains")
 
   /** Extract the API representation of a source file */
   def apiSource(tree: Tree): Seq[api.ClassLike] = {

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

@@ -599,7 +599,7 @@ object Checking {
   def checkNoPrivateLeaks(sym: Symbol)(using Context): Type = {
     class NotPrivate extends TypeMap {
       var errors: List[() => String] = Nil
-      var inCaptureSet: Boolean = false
+      private var inCaptureSet: Boolean = false
 
       def accessBoundary(sym: Symbol): Symbol =
         if (sym.is(Private) || !sym.owner.isClass) sym.owner
@@ -622,7 +622,7 @@ object Checking {
         }
         && !(inCaptureSet && other.isAllOf(LocalParamAccessor))
             // class parameters in capture sets are not treated as leaked since in
-            // phase -Ycc these are treated as normal vals.
+            // phase CheckCaptures these are treated as normal vals.
 
       def apply(tp: Type): Type = tp match {
         case tp: NamedType =>
@@ -660,9 +660,10 @@ object Checking {
         case tp @ AnnotatedType(underlying, annot)
         if annot.symbol == defn.RetainsAnnot || annot.symbol == defn.RetainsByNameAnnot =>
           val underlying1 = this(underlying)
+          val saved = inCaptureSet
           inCaptureSet = true
           val annot1 = annot.mapWith(this)
-          inCaptureSet = false
+          inCaptureSet = saved
           derivedAnnotatedType(tp, underlying1, annot1)
         case _ =>
           mapOver(tp)
@@ -1434,6 +1435,10 @@ trait Checking {
       val kind = if pattern then "pattern selector" else "value"
       report.warning(MatchableWarning(tp, pattern), pos)
 
+  /** Check that there is an implicit capability to throw a checked exception
+   *  if the saferExceptions feature is turned on. Return that capability is it exists,
+   *  EmptyTree otherwise.
+   */
   def checkCanThrow(tp: Type, span: Span)(using Context): Tree =
     if Feature.enabled(Feature.saferExceptions) && tp.isCheckedException then
       ctx.typer.implicitArgTree(defn.CanThrowClass.typeRef.appliedTo(tp), span)

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

@@ -319,7 +319,8 @@ trait ImportSuggestions:
    *  If there's nothing to suggest, an empty string is returned.
    */
   override def importSuggestionAddendum(pt: Type)(using Context): String =
-    if ctx.phase == Phases.checkCapturesPhase then return ""
+    if ctx.phase == Phases.checkCapturesPhase then
+      return "" // it's too late then to look for implicits
     val (fullMatches, headMatches) =
       importSuggestions(pt)(using ctx.fresh.setExploreTyperState())
     implicits.println(i"suggestions for $pt in ${ctx.owner} = ($fullMatches%, %, $headMatches%, %)")

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

@@ -13,7 +13,6 @@ import Decorators._
 import config.Printers.{gadts, typr}
 import annotation.tailrec
 import reporting._
-import cc.{CapturingType, derivedCapturingType}
 import collection.mutable
 
 import scala.annotation.internal.sharable
@@ -526,10 +525,10 @@ object Inferencing {
   }
 
   /** Replace every top-level occurrence of a wildcard type argument by
-    *  a fresh skolem type. The skolem types are of the form $i.CAP, where
-    *  $i is a skolem of type `scala.internal.TypeBox`, and `CAP` is its
-    *  type member. See the documentation of `TypeBox` for a rationale why we do this.
-    */
+   *  a fresh skolem type. The skolem types are of the form $i.CAP, where
+   *  $i is a skolem of type `scala.internal.TypeBox`, and `CAP` is its
+   *  type member. See the documentation of `TypeBox` for a rationale why we do this.
+   */
   def captureWildcards(tp: Type)(using Context): Type = derivedOnDealias(tp) {
     case tp @ AppliedType(tycon, args) if tp.hasWildcardArg =>
       val tparams = tycon.typeParamSymbols
@@ -545,7 +544,6 @@ object Inferencing {
     case tp: RefinedType => tp.derivedRefinedType(captureWildcards(tp.parent), tp.refinedName, tp.refinedInfo)
     case tp: RecType => tp.derivedRecType(captureWildcards(tp.parent))
     case tp: LazyRef => captureWildcards(tp.ref)
-    case CapturingType(parent, refs) => tp.derivedCapturingType(captureWildcards(parent), refs)
     case tp: AnnotatedType => tp.derivedAnnotatedType(captureWildcards(tp.parent), tp.annot)
     case _ => tp
   }
@@ -736,7 +734,6 @@ trait Inferencing { this: Typer =>
             if !argType.isSingleton then argType = SkolemType(argType)
             argType <:< tvar
         case _ =>
-          () // scala-meta complains if this is missing, but I could not mimimize further
   end constrainIfDependentParamRef
 }
 

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

@@ -291,16 +291,14 @@ trait TypeAssigner {
 
   def safeSubstMethodParams(mt: MethodType, argTypes: List[Type])(using Context): Type =
     if mt.isResultDependent then safeSubstParams(mt.resultType, mt.paramRefs, argTypes)
+    else if mt.isCaptureDependent then mt.resultType.substParams(mt, argTypes)
     else mt.resultType
 
   def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(using Context): Apply = {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
         if (fntpe.paramInfos.hasSameLengthAs(args) || ctx.phase.prev.relaxedTyping)
-          if fntpe.isCaptureDependent then
-            fntpe.resultType.substParams(fntpe, args.tpes)
-          else
-            safeSubstMethodParams(fntpe, args.tpes)
+          safeSubstMethodParams(fntpe, args.tpes)
         else
           errorType(i"wrong number of arguments at ${ctx.phase.prev} for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.srcPos)
       case t =>

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

@@ -1874,12 +1874,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val expr1 = typed(tree.expr, defn.ThrowableType)
     val cap = checkCanThrow(expr1.tpe.widen, tree.span)
     val res = Throw(expr1).withSpan(tree.span)
-    if cap.isEmpty || !ctx.settings.Ycc.value || ctx.isAfterTyper then res
-    else
+    if ctx.settings.Ycc.value && !cap.isEmpty && !ctx.isAfterTyper then
+      // Record access to the CanThrow capabulity recovered in `cap` by wrapping
+      // the type of the `throw` (i.e. Nothing) in a `@requiresCapability` annotatoon.
       Typed(res,
         TypeTree(
           AnnotatedType(res.tpe,
             Annotation(defn.RequiresCapabilityAnnot, cap))))
+    else res
 
   def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral = {
     val elemProto = pt.stripNull.elemType match {

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -241,8 +241,9 @@ class CompilationTests {
     given TestGroup = TestGroup("recheck")
     aggregateTests(
       compileFilesInDir("tests/new", recheckOptions),
-      compileFilesInDir("tests/pos", recheckOptions, FileFilter.exclude(TestSources.posTestRecheckExcluded)),
-      compileFilesInDir("tests/run", recheckOptions, FileFilter.exclude(TestSources.runTestRecheckExcluded))
+      //Following are disabled since they take too long for what they provide.
+      //compileFilesInDir("tests/pos", recheckOptions, FileFilter.exclude(TestSources.posTestRecheckExcluded)),
+      //compileFilesInDir("tests/run", recheckOptions, FileFilter.exclude(TestSources.runTestRecheckExcluded))
     ).checkCompile()
 
   // Explicit nulls tests