i8215 Add ability to detect attempted Tasty inspection of a Java class

Author: gzoller

compiler/src/dotty/tools/dotc/fromtasty/JavaCompilationUnit.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 JavaCompilationUnit(val className: String) extends CompilationUnit(NoSource) {
+  override def toString: String = s"java class file $className"
+}

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

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

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

@@ -65,6 +65,11 @@ 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_getJavaClassname(self: Context): Option[String] = 
+    self.compilationUnit match {
+      case j: fromtasty.JavaCompilationUnit => Some(j.className)
+      case _ => None
+    }
 
 
   ///////////////

library/src/scala/tasty/Reflection.scala

@@ -473,6 +473,9 @@ 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 getJavaClassname(): Option[String] = internal.Context_getJavaClassname(self)
+
   }
 
 

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

@@ -162,6 +162,9 @@ 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_getJavaClassname(self: Context): Option[String]
+
 
   ///////////////
   // REPORTING //

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

@@ -0,0 +1,24 @@
+import scala.tasty.Reflection
+import scala.tasty.inspector._
+
+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"))
+  }
+}
+
+class TestInspector() extends TastyInspector
+
+  var gotJava: Option[String] = None
+
+  protected def processCompilationUnit(reflect: Reflection)(root: reflect.Tree): Unit = 
+    import reflect.{given,_}
+    gotJava = reflect.rootContext.getJavaClassname()