Run (a part of) PostTyper on java sources

Author: TheElectronWill

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -87,9 +87,12 @@ class Pickler extends Phase {
     }
   }
 
+  protected def discardBeforePickler(unit: CompilationUnit)(using Context): Boolean =
+    unit.isJava // stop here for java files
+
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
-    val result = super.runOn(units)
-    if (ctx.settings.YtestPickler.value)
+    val result = super.runOn(units.filterNot(discardBeforePickler))
+    if ctx.settings.YtestPickler.value
       testUnpickler(
         using ctx.fresh
             .setPeriod(Period(ctx.runId + 1, FirstPhaseId))

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -71,7 +71,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
   override def transformPhase(using Context): Phase = thisPhase.next
 
   protected def newTransformer(using Context): Transformer =
-    new PostTyperTransformer
+    if ctx.compilationUnit.isJava then LimitedChecksTransformer()
+    else PostTyperTransformer()
 
   val superAcc: SuperAccessors = new SuperAccessors(thisPhase)
   val synthMbr: SyntheticMembers = new SyntheticMembers(thisPhase)
@@ -85,6 +86,65 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     // TODO fill in
   }
 
+  private def normalizeTypeArgs(tree: TypeApply)(using Context): TypeApply = tree.tpe match
+    case pt: PolyType => // wait for more arguments coming
+      tree
+    case _ =>
+      def decompose(tree: TypeApply): (Tree, List[Tree]) = tree.fun match
+        case fun: TypeApply =>
+          val (tycon, args) = decompose(fun)
+          (tycon, args ++ tree.args)
+        case _ =>
+          (tree.fun, tree.args)
+      end decompose
+      def reorderArgs(pnames: List[Name], namedArgs: List[NamedArg], otherArgs: List[Tree]): List[Tree] = pnames match
+        case pname :: pnames1 =>
+          namedArgs.partition(_.name == pname) match
+            case (NamedArg(_, arg) :: _, namedArgs1) =>
+              arg :: reorderArgs(pnames1, namedArgs1, otherArgs)
+            case _ =>
+              val otherArg :: otherArgs1 = otherArgs
+              otherArg :: reorderArgs(pnames1, namedArgs, otherArgs1)
+        case nil =>
+          assert(namedArgs.isEmpty && otherArgs.isEmpty)
+          Nil
+      end reorderArgs
+
+      val (tycon, args) = decompose(tree)
+      tycon.tpe.widen match
+        case tp: PolyType if args.exists(isNamedArg) =>
+          val (namedArgs, otherArgs) = args.partition(isNamedArg)
+          val args1 = reorderArgs(tp.paramNames, namedArgs.asInstanceOf[List[NamedArg]], otherArgs)
+          TypeApply(tycon, args1).withSpan(tree.span).withType(tree.tpe)
+        case _ =>
+          tree
+
+  class LimitedChecksTransformer extends Transformer {
+    private def checkAppliedTypes(tree: Tree)(using Context): Unit = tree match
+      case tpt: TypeTree =>
+        Checking.checkAppliedTypesIn(tpt)
+      case app: AppliedTypeTree =>
+        Checking.checkAppliedType(app, EmptyTree)
+      case _ =>
+
+    override def transform(tree: Tree)(using Context): Tree =
+      ctx.debuglog(s"LimitedChecksTransformer.transform(${tree.show})")
+      ctx.debuglog(s"  -- $tree")
+      tree match
+        case Select(qual, name) if name.isTypeName =>
+          Checking.checkRealizable(qual.tpe, qual.posd)
+          if name.isTypeName then
+            super.transform(tree)(using ctx.addMode(Mode.Type))
+        case tree: TypeApply =>
+          val TypeApply(fn, args) = normalizeTypeArgs(tree)
+          args.foreach(checkAppliedTypes)
+        case tree: ValOrDefDef =>
+          checkAppliedTypes(tree.tpt)
+        case _ =>
+          super.transform(tree)
+      tree
+  }
+
   class PostTyperTransformer extends Transformer {
 
     private var inJavaAnnot: Boolean = false
@@ -180,41 +240,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       }
     }
 
-    private def normalizeTypeArgs(tree: TypeApply)(using Context): TypeApply = tree.tpe match {
-      case pt: PolyType => // wait for more arguments coming
-        tree
-      case _ =>
-        def decompose(tree: TypeApply): (Tree, List[Tree]) = tree.fun match {
-          case fun: TypeApply =>
-            val (tycon, args) = decompose(fun)
-            (tycon, args ++ tree.args)
-          case _ =>
-            (tree.fun, tree.args)
-        }
-        def reorderArgs(pnames: List[Name], namedArgs: List[NamedArg], otherArgs: List[Tree]): List[Tree] = pnames match {
-          case pname :: pnames1 =>
-            namedArgs.partition(_.name == pname) match {
-              case (NamedArg(_, arg) :: _, namedArgs1) =>
-                arg :: reorderArgs(pnames1, namedArgs1, otherArgs)
-              case _ =>
-                val otherArg :: otherArgs1 = otherArgs
-                otherArg :: reorderArgs(pnames1, namedArgs, otherArgs1)
-            }
-          case nil =>
-            assert(namedArgs.isEmpty && otherArgs.isEmpty)
-            Nil
-        }
-        val (tycon, args) = decompose(tree)
-        tycon.tpe.widen match {
-          case tp: PolyType if args.exists(isNamedArg) =>
-            val (namedArgs, otherArgs) = args.partition(isNamedArg)
-            val args1 = reorderArgs(tp.paramNames, namedArgs.asInstanceOf[List[NamedArg]], otherArgs)
-            TypeApply(tycon, args1).withSpan(tree.span).withType(tree.tpe)
-          case _ =>
-            tree
-        }
-    }
-
     private object dropInlines extends TreeMap {
       override def transform(tree: Tree)(using Context): Tree = tree match {
         case Inlined(call, _, expansion) =>

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

@@ -92,9 +92,9 @@ class FrontEnd extends Phase {
   }
 
   protected def discardAfterTyper(unit: CompilationUnit)(using Context): Boolean =
-    unit.isJava || unit.suspended
+    unit.suspended
 
-  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
     val unitContexts =
       for unit <- units yield
         ctx.inform(s"compiling ${unit.source}")
@@ -106,7 +106,7 @@ class FrontEnd extends Phase {
       enterSyms(using remaining.head)
       remaining = remaining.tail
 
-    if (firstXmlPos.exists && !defn.ScalaXmlPackageClass.exists)
+    if firstXmlPos.exists && !defn.ScalaXmlPackageClass.exists then
       ctx.error("""To support XML literals, your project must depend on scala-xml.
                   |See https://github.com/scala/scala-xml for more information.""".stripMargin,
         firstXmlPos)
@@ -130,7 +130,6 @@ class FrontEnd extends Phase {
                     |
                     |To fix this, place macros in one set of files and their callers in another.$enableXprintSuspensionHint""")
     newUnits
-  }
 
   def run(using Context): Unit = unsupported("run")
 }