implemented requested changes

Author: gzoller

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

@@ -3,10 +3,9 @@ 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.
+/** 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 JavaCompilationUnit(val className: String) extends CompilationUnit(NoSource) {
   override def toString: String = s"Java class file $className"

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

@@ -49,7 +49,7 @@ class ReadTasty extends Phase {
               }
             case tree: Tree[?] =>
               cls.denot.infoOrCompleter match {
-                case _: NoLoader => Some(NonTastyScalaCompilationUnit(cls.fullName.toString))
+                case _: NoLoader => Some(Scala2CompilationUnit(cls.fullName.toString))
                 case _ if cls.flags.is(Flags.JavaDefined) => Some(JavaCompilationUnit(cls.fullName.toString))
                 case _ => alreadyLoaded()
               }

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.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 Scala2 class file (which has no .tasty file).  
+ *  In this case we still want to return the fact we found it so that higher-up we can take appropriate 
+ *  action if desired.
+ */
+class Scala2CompilationUnit(val className: String) extends CompilationUnit(NoSource) {
+  override def toString: String = s"Scala2 class file $className"
+}

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

@@ -65,15 +65,13 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Context_requiredClass(self: Context)(path: String): Symbol = self.requiredClass(path)
   def Context_requiredModule(self: Context)(path: String): Symbol = self.requiredModule(path)
   def Context_requiredMethod(self: Context)(path: String): Symbol = self.requiredMethod(path)
-  def Context_javaCompilationUnitClassname(self: Context): Option[String] = 
+  def Context_isJavaCompilationUnit(self: Context): Boolean = self.compilationUnit.isInstanceOf[fromtasty.JavaCompilationUnit]
+  def Context_isScala2CompilationUnit(self: Context): Boolean = self.compilationUnit.isInstanceOf[fromtasty.Scala2CompilationUnit]
+  def Context_compilationUnitClassname(self: Context): String = 
     self.compilationUnit match {
-      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
+      case cu: fromtasty.JavaCompilationUnit => cu.className
+      case cu: fromtasty.Scala2CompilationUnit => cu.className
+      case cu => ""
     }
 
 

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

@@ -473,11 +473,14 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     /** Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */
     def requiredMethod(path: String): Symbol = internal.Context_requiredMethod(self)(path)
 
-    /** 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)
+    /** Returns true if we've tried to reflect on a Java class. */
+    def isJavaCompilationUnit(): Boolean = internal Context_isJavaCompilationUnit(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)
+    /** Returns true if we've tried to reflect on a Scala2 (non-Tasty) class. */
+    def isScala2CompilationUnit(): Boolean = internal Context_isScala2CompilationUnit(self)
+
+    /** Class name of the current CompilationUnit */
+    def compilationUnitClassname(): String = internal.Context_compilationUnitClassname(self)
   }
 
 

library/src/scala/tasty/Reflection.scala

@@ -162,11 +162,14 @@ trait CompilerInterface {
   /** Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */
   def Context_requiredMethod(self: Context)(path: String): Symbol
 
-  /** 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]
+  /** Returns true if we've tried to reflect on a Java class. */
+  def Context_isJavaCompilationUnit(self: Context): Boolean
 
-  /** 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]
+  /** Returns true if we've tried to reflect on a Scala2 (non-Tasty) class. */
+  def Context_isScala2CompilationUnit(self: Context): Boolean
+
+  /** Class name of the current CompilationUnit */
+  def Context_compilationUnitClassname(self: Context): String
 
 
   ///////////////

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

@@ -9,29 +9,34 @@ object Test {
     // Tasty Scala Class
     val inspect1 = new TestInspector()
     inspect1.inspect("", List("I8215"))
-    assert(inspect1.gotJava == None)
-    assert(inspect1.gotNonTastyScala == None)
+    assert(inspect1.isJava == false)
+    assert(inspect1.isScala2 == false)
+    assert(inspect1.className == "")
 
     // Java Class
     val inspect2 = new TestInspector()
     inspect2.inspect("", List("java.util.UUID"))
-    assert(inspect2.gotJava == Some("java.util.UUID"))
-    assert(inspect2.gotNonTastyScala == None)
+    assert(inspect2.isJava == true)
+    assert(inspect2.isScala2 == false)
+    assert(inspect2.className == "java.util.UUID")
 
     // 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"))    
+    assert(inspect3.isJava == false)
+    assert(inspect3.isScala2 == true)
+    assert(inspect3.className == "scala.collection.immutable.RedBlackTree")
   }
 }
 
 class TestInspector() extends TastyInspector
 
-  var gotJava: Option[String] = None
-  var gotNonTastyScala: Option[String] = None
+  var isJava: Boolean = false
+  var isScala2: Boolean = false
+  var className: String = ""
 
   protected def processCompilationUnit(reflect: Reflection)(root: reflect.Tree): Unit = 
     import reflect.{given,_}
-    gotJava = reflect.rootContext.javaCompilationUnitClassname()
-    gotNonTastyScala = reflect.rootContext.nonTastyScalaCompilationUnitClassname()
+    isJava = reflect.rootContext.isJavaCompilationUnit()
+    isScala2 = reflect.rootContext.isScala2CompilationUnit()
+    className = reflect.rootContext.compilationUnitClassname()