tracked inference review changes

Author: KacperFKorban

.github/workflows/ci.yaml

@@ -26,10 +26,10 @@ on:
     - cron: '0 3 * * *'  # Every day at 3 AM
   workflow_dispatch:
 
-# Cancels any in-progress runs within the same group identified by workflow name and GH reference (branch or tag)
+# Cancels any in-progress runs within the same group identified by workflow name and GH reference (branch or tag) 
 # For example it would:
 # - terminate previous PR CI execution after pushing more changes to the same PR branch
-# - terminate previous on-push CI run after merging new PR to main
+# - terminate previous on-push CI run after merging new PR to main  
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
@@ -831,7 +831,7 @@ jobs:
           path: .
       - name: Prepare MSI package
         shell: bash
-        run: |
+        run: | 
           msiInstaller="scala3-${{ env.RELEASE_TAG }}.msi"
           mv scala.msi "${msiInstaller}"
           sha256sum "${msiInstaller}" > "${msiInstaller}.sha256"
@@ -870,7 +870,7 @@ jobs:
       #       ${upload("tar.gz archive", s"$filename.tar.gz", "application/gzip", distribution)}
       #       ${upload("tar.gz archive SHA", s"$filename.tar.gz.sha256", "text/plain", distribution)}
       # """
-      # def uploadMSI() =
+      # def uploadMSI() = 
       #     val distribution = "Windows x86_64 MSI"
       #     s"""
       #       # $distribution

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

@@ -2753,7 +2753,7 @@ object SymDenotations {
     def complete(denot: SymDenotation)(using Context): Unit
 
     /** Is this a completer for an explicit type tree */
-    def isNonInfering: Boolean = false
+    def isExplicit: Boolean = false
 
     def apply(sym: Symbol): LazyType = this
     def apply(module: TermSymbol, modcls: ClassSymbol): LazyType = this

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

@@ -278,7 +278,7 @@ class Namer { typer: Typer =>
                 if rhs.isEmpty || flags.is(Opaque) then flags |= Deferred
             if flags.is(Param) then tree.rhs else analyzeRHS(tree.rhs)
 
-        def isNonInferingTree(tree: ValOrDefDef): Boolean =
+        def hasExplicitType(tree: ValOrDefDef): Boolean =
           !tree.tpt.isEmpty || tree.mods.isOneOf(TermParamOrAccessor)
 
         // to complete a constructor, move one context further out -- this
@@ -294,8 +294,8 @@ class Namer { typer: Typer =>
 
         val completer = tree match
           case tree: TypeDef => TypeDefCompleter(tree)(cctx)
-          case tree: ValOrDefDef if Feature.enabled(Feature.modularity) && isNonInferingTree(tree) =>
-            NonInferingCompleter(tree)(cctx)
+          case tree: ValOrDefDef if Feature.enabled(Feature.modularity) && hasExplicitType(tree) =>
+            new Completer(tree, isExplicit = true)(cctx)
           case _ => Completer(tree)(cctx)
         val info = adjustIfModule(completer, tree)
         createOrRefine[Symbol](tree, name, flags, ctx.owner, _ => info,
@@ -805,7 +805,7 @@ class Namer { typer: Typer =>
   }
 
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
-  class Completer(val original: Tree)(ictx: Context) extends LazyType with SymbolLoaders.SecondCompleter {
+  class Completer(val original: Tree, override val isExplicit: Boolean = false)(ictx: Context) extends LazyType with SymbolLoaders.SecondCompleter {
 
     protected def localContext(owner: Symbol): FreshContext = ctx.fresh.setOwner(owner).setTree(original)
 
@@ -1738,10 +1738,6 @@ class Namer { typer: Typer =>
     }
   }
 
-  class NonInferingCompleter(original: ValOrDefDef)(ictx: Context) extends Completer(original)(ictx) {
-    override def isNonInfering: Boolean = true
-  }
-
   /** Possible actions to perform when deciding on a forwarder for a member */
   private enum CanForward:
     case Yes
@@ -2030,7 +2026,7 @@ class Namer { typer: Typer =>
 
   extension (sym: Symbol)
     private def infoWithForceNonInferingCompleter(using Context): Type = sym.infoOrCompleter match
-      case tpe: LazyType if tpe.isNonInfering => sym.info
+      case tpe: LazyType if tpe.isExplicit => sym.info
       case tpe if sym.isType => sym.info
       case info => info
 

docs/_docs/reference/experimental/modularity.md

@@ -116,7 +116,7 @@ ClsParam  ::=  {Annotation} [{Modifier | ‘tracked’} (‘val’ | ‘var’)]
 
 The (soft) `tracked` modifier is only allowed for `val` parameters of classes.
 
-**Tracked inference**
+### Tracked inference
 
 In some cases `tracked` can be infered and doesn't have to be written
 explicitly. A common such case is when a class parameter is referenced in the
@@ -147,7 +147,7 @@ class Klass[A: {TC as tc}]
 
 Here, `tc` is a context bound with an associated type `T`, so `tracked` will be inferred for `tc`.
 
-**Discussion**
+### Discussion
 
 Since `tracked` is so useful, why not assume it by default? First, `tracked` makes sense only for `val` parameters. If a class parameter is not also a field declared using `val` then there's nothing to refine in the constructor result type. One could think of at least making all `val` parameters tracked by default, but that would be a backwards incompatible change. For instance, the following code would break: