new Invisble flag semantics

- now invisible members are visible in typer when resolving SELECTin from TASTy.
- add sbt-test/tasty-compat test to demonstrate when inline method calls forwarder

Author: bishabosha

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

@@ -1072,7 +1072,7 @@ object Denotations {
     def filterDisjoint(denots: PreDenotation)(using Context): SingleDenotation =
       if (denots.exists && denots.matches(this)) NoDenotation else this
     def filterWithFlags(required: FlagSet, excluded: FlagSet)(using Context): SingleDenotation =
-      val realExcluded = if ctx.isAfterTyper then excluded else excluded | Invisible
+      val realExcluded = if ctx.isAfterTyper then excluded else excluded | (if ctx.mode.is(Mode.ResolveFromTASTy) then EmptyFlags else Invisible)
       def symd: SymDenotation = this match
         case symd: SymDenotation => symd
         case _ => symbol.denot

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

@@ -105,7 +105,7 @@ object Mode {
 
   /** Use previous Scheme for implicit resolution. Currently significant
    *  in 3.0-migration where we use Scala-2's scheme instead and in 3.5 and 3.6-migration
-   *  where we use the previous scheme up to 3.4 for comparison with the new scheme. 
+   *  where we use the previous scheme up to 3.4 for comparison with the new scheme.
    */
   val OldImplicitResolution: Mode = newMode(15, "OldImplicitResolution")
 
@@ -125,6 +125,9 @@ object Mode {
   /** Read original positions when unpickling from TASTY */
   val ReadPositions: Mode = newMode(17, "ReadPositions")
 
+  /** We are resolving a SELECT name from TASTy */
+  val ResolveFromTASTy: Mode = newMode(18, "ResolveFromTASTy")
+
   /** We are elaborating the fully qualified name of a package clause.
    *  In this case, identifiers should never be imported.
    */

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

@@ -617,7 +617,7 @@ object SymDenotations {
       case _ =>
         // Otherwise, no completion is necessary, see the preconditions of `markAbsent()`.
         (myInfo `eq` NoType)
-        || is(Invisible) && ctx.isTyper
+        || (is(Invisible) && !ctx.mode.is(Mode.ResolveFromTASTy)) && ctx.isTyper
         || is(ModuleVal, butNot = Package) && moduleClass.isAbsent(canForce)
     }
 

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1563,7 +1563,7 @@ class TreeUnpickler(reader: TastyReader,
                *  - sbt-test/tasty-compat/remove-override
                *  - sbt-test/tasty-compat/move-method
                */
-              def lookupInSuper =
+              def lookupInSuper(using Context) =
                 val cls = ownerTpe.classSymbol
                 if cls.exists then
                   cls.asClass.classDenot
@@ -1572,14 +1572,18 @@ class TreeUnpickler(reader: TastyReader,
                 else
                   NoDenotation
 
-              val denot =
+
+              def searchDenot(using Context): Denotation =
                 if owner.is(JavaAnnotation) && name == nme.CONSTRUCTOR then
                   // #19951 Fix up to read TASTy produced before 3.5.0 -- ignore the signature
                   ownerTpe.nonPrivateDecl(name).asSeenFrom(prefix)
                 else
                   val d = ownerTpe.decl(name).atSignature(sig, target)
                   (if !d.exists then lookupInSuper else d).asSeenFrom(prefix)
 
+              val denot = inContext(ctx.addMode(Mode.ResolveFromTASTy)):
+                searchDenot // able to resolve Invisible members
+
               makeSelect(qual, name, denot)
             case REPEATED =>
               val elemtpt = readTpt()

sbt-test/tasty-compat/add-param-unroll/a-changes/A.scala

@@ -0,0 +1,9 @@
+package a
+
+import scala.annotation.unroll
+
+object A {
+
+  def foo(s: String, x: Int, @unroll b: Boolean = true): String = s + x + b
+
+}

sbt-test/tasty-compat/add-param-unroll/a/A.scala

@@ -0,0 +1,9 @@
+package a
+
+import scala.annotation.unroll
+
+object A {
+
+  def foo(s: String, x: Int): String = s + x
+
+}

sbt-test/tasty-compat/add-param-unroll/b/B.scala

@@ -0,0 +1,7 @@
+package b
+
+import a.*
+
+object B {
+  transparent inline def caller = A.foo("abc", 2)
+}

sbt-test/tasty-compat/add-param-unroll/build.sbt

@@ -0,0 +1,36 @@
+lazy val commonSettings = Seq(
+  scalacOptions += "-experimental",
+)
+
+lazy val printSettings = Seq(
+  scalacOptions += "-Yprint-tasty",
+)
+
+lazy val a = project.in(file("a"))
+  .settings(commonSettings)
+  .settings(
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "b-input"
+  )
+
+lazy val b = project.in(file("b"))
+  .settings(commonSettings)
+  .settings(
+    Compile / unmanagedClasspath += (ThisBuild / baseDirectory).value / "b-input",
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-input"
+  )
+
+lazy val `a-changes` = project.in(file("a-changes"))
+  .settings(commonSettings)
+  .settings(
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-input"
+  )
+
+lazy val c = project.in(file("c"))
+  .settings(commonSettings)
+  .settings(printSettings)
+  .settings(
+    // scalacOptions ++= Seq("-from-tasty", "-Ycheck:readTasty", "-Xfatal-warnings", "-Xprint:readTasty", "-Xprint-types"),
+    // Compile / sources := Seq(new java.io.File("c-input/B.tasty")),
+    Compile / unmanagedClasspath += (ThisBuild / baseDirectory).value / "c-input",
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-output"
+  )

sbt-test/tasty-compat/add-param-unroll/c/C.scala

@@ -0,0 +1,5 @@
+import b.*
+
+object C {
+  val res = B.caller
+}

sbt-test/tasty-compat/add-param-unroll/project/DottyInjectedPlugin.scala

@@ -0,0 +1,11 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := sys.props("plugin.scalaVersion")
+  )
+}

sbt-test/tasty-compat/add-param-unroll/test

@@ -0,0 +1,8 @@
+# compile library A
+> a/compile
+# compile library B, from source, against A
+> b/compile
+# add a new parameter in method to library A', using @unroll to generate a forwarder
+> a-changes/compile
+# compile B, from tasty, against A', it should still compile: the generated forwarder is resolved.
+> c/compile

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -227,7 +227,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   PARAMalias                                                       -- Parameter is alias of a superclass parameter
                   EXPORTED                                                         -- An export forwarder
                   OPEN                                                             -- an open class
-                  INVISIBLE                                                        -- invisible during typechecking
+                  INVISIBLE                                                        -- invisible during typechecking, except when resolving from TASTy
                   TRACKED                                                          -- a tracked class parameter / a dependent class
                   Annotation