Fixed flags bug in ReadTasty

Author: gzoller

compiler/src/dotty/tools/dotc/fromtasty/JavaCompilationUnit.scala

@@ -9,5 +9,5 @@ import dotty.tools.dotc.util.NoSource
  * but we want to return the fact we found it so that higher-up we can take appropriate action if desired.
  */
 class JavaCompilationUnit(val className: String) extends CompilationUnit(NoSource) {
-  override def toString: String = s"java class file $className"
+  override def toString: String = s"Java class file $className"
 }

compiler/src/dotty/tools/dotc/fromtasty/NonTastyScalaCompilationUnit.scala

@@ -0,0 +1,13 @@
+package dotty.tools.dotc.fromtasty
+
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.util.NoSource
+
+/**
+ * A marker CompilationUnit to return up the call stack from ReadTasty.  This will tell us that we've
+ * encountered, and attempted to inspect, a Java class file.  We can't TASTy-inspect a Java class obviously,
+ * but we want to return the fact we found it so that higher-up we can take appropriate action if desired.
+ */
+class NonTastyScalaCompilationUnit(val className: String) extends CompilationUnit(NoSource) {
+  override def toString: String = s"Non-Tasty Scala class file $className"
+}

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -48,10 +48,11 @@ class ReadTasty extends Phase {
                 Some(unit)
               }
             case tree: Tree[?] =>
-              if( cls.flags.is(Flags.JavaDefined) )  // Is this a Java class we've tried to inspect?
-                Some(JavaCompilationUnit(cls.fullName.toString))
-              else
-                alreadyLoaded()
+              cls.denot.infoOrCompleter match {
+                case _: NoLoader => Some(NonTastyScalaCompilationUnit(cls.fullName.toString))
+                case _ if cls.flags.is(Flags.JavaDefined) => Some(JavaCompilationUnit(cls.fullName.toString))
+                case _ => alreadyLoaded()
+              }
             case _ =>
               cannotUnpickle(s"its class file does not have a TASTY attribute")
           }

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -70,6 +70,11 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       case j: fromtasty.JavaCompilationUnit => Some(j.className)
       case _ => None
     }
+  def Context_nonTastyScalaCompilationUnitClassname(self: Context): Option[String] = 
+    self.compilationUnit match {
+      case s: fromtasty.NonTastyScalaCompilationUnit => Some(s.className)
+      case _ => None
+    }
 
 
   ///////////////

library/src/scala/tasty/Reflection.scala

@@ -476,6 +476,8 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     /** Get Java class name if we've accidentally tried to reflect on a Java class.  None returned if TASTy class. */
     def javaCompilationUnitClassname(): Option[String] = internal.Context_javaCompilationUnitClassname(self)
 
+    /** Get Scala class name if attempted reflection is performed on an older Scala file w/o Tasty information present. */
+    def nonTastyScalaCompilationUnitClassname(): Option[String] = internal.Context_nonTastyScalaCompilationUnitClassname(self)
   }
 
 

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -165,6 +165,9 @@ trait CompilerInterface {
   /** Get Java class name if we've accidentally tried to reflect on a Java class.  None returned if TASTy class. */
   def Context_javaCompilationUnitClassname(self: Context): Option[String]
 
+  /** Get Scala class name if attempted reflection is performed on an older Scala file w/o Tasty information present. */
+  def Context_nonTastyScalaCompilationUnitClassname(self: Context): Option[String]
+
 
   ///////////////
   // REPORTING //

tests/run-custom-args/tasty-inspector/i8215.scala

@@ -5,20 +5,33 @@ case class I8215(id: String)
 
 object Test {
   def main(args: Array[String]): Unit = {
-  	val inspect1 = new TestInspector()
-  	inspect1.inspect("", List("I8215"))
-  	assert(inspect1.gotJava == None)
 
-  	val inspect2 = new TestInspector()
-  	inspect2.inspect("", List("java.util.UUID"))
-  	assert(inspect2.gotJava == Some("java.util.UUID"))
+    // Tasty Scala Class
+    val inspect1 = new TestInspector()
+    inspect1.inspect("", List("I8215"))
+    assert(inspect1.gotJava == None)
+    assert(inspect1.gotNonTastyScala == None)
+
+    // Java Class
+    val inspect2 = new TestInspector()
+    inspect2.inspect("", List("java.util.UUID"))
+    assert(inspect2.gotJava == Some("java.util.UUID"))
+    assert(inspect2.gotNonTastyScala == None)
+
+    // Legacy non-Tasty Scala class
+    val inspect3 = new TestInspector()
+    inspect3.inspect("", List("scala.collection.immutable.RedBlackTree"))
+    assert(inspect3.gotJava == None)
+    assert(inspect3.gotNonTastyScala == Some("scala.collection.immutable.RedBlackTree"))    
   }
 }
 
 class TestInspector() extends TastyInspector
 
   var gotJava: Option[String] = None
+  var gotNonTastyScala: Option[String] = None
 
   protected def processCompilationUnit(reflect: Reflection)(root: reflect.Tree): Unit = 
     import reflect.{given,_}
-    gotJava = reflect.rootContext.javaCompilationUnitClassname()
+    gotJava = reflect.rootContext.javaCompilationUnitClassname()
+    gotNonTastyScala = reflect.rootContext.nonTastyScalaCompilationUnitClassname()