wip

Author: SethTisue

build.sbt

@@ -40,7 +40,7 @@ lazy val `genjavadoc-plugin` = (project in file("plugin"))
       val default = (unmanagedSourceDirectories in Compile).value
       def r(from: String, to: String) = default.map(f => new java.io.File(f.getPath.replaceAll(from, to)))
       if (scalaVersion.value == "2.12.0") r("""/scala-2\.12$""", "/scala-2.11")
-      else if (scalaMajorVersion.value == 13) r("""/scala-2\.13[^/]*$""", "/scala-2.12")
+      else if (scalaMajorVersion.value == 13) r("""/scala-2\.13[^/]*$""", "/scala-2.13")
       else default
     },
     crossVersion := CrossVersion.full,

plugin/src/main/scala/com/typesafe/genjavadoc/NeedsJavaSig.scala renamed to plugin/src/main/scala-2.11/com/typesafe/genjavadoc/NeedsJavaSig.scala

@@ -0,0 +1,40 @@
+package com.typesafe.genjavadoc
+
+trait NeedsJavaSig { this: TransformCake =>
+
+  import global._
+  import definitions._
+
+  def needsJavaSig(tp: Type): Boolean =
+    !settings.Ynogenericsig.value && NeedsSigCollector.collect(tp)
+
+  private object NeedsSigCollector extends TypeCollector(false) {
+    private def rebindInnerClass(pre: Type, cls: Symbol): Type =
+      if (cls.owner.isClass) cls.owner.tpe else pre // why not cls.isNestedClass?
+    override def traverse(tp: Type): Unit = {
+      if (!result) {
+        tp match {
+          case st: SubType =>
+            traverse(st.supertype)
+          case TypeRef(pre, sym, args) =>
+            if (sym == ArrayClass) args foreach traverse
+            else if (sym.isTypeParameterOrSkolem || sym.isExistentiallyBound || !args.isEmpty) result = true
+            else if (sym.isClass) traverse(rebindInnerClass(pre, sym)) // #2585
+            else if (!sym.owner.isPackageClass) traverse(pre)
+          case PolyType(_, _) | ExistentialType(_, _) =>
+            result = true
+          case RefinedType(parents, _) =>
+            parents foreach traverse
+          case ClassInfoType(parents, _, _) =>
+            parents foreach traverse
+          case at: AnnotatedType =>
+            traverse(at.underlying)
+          case _ =>
+            mapOver(tp)
+        }
+      }
+    }
+  }
+
+}
+

plugin/src/main/scala-2.12/com/typesafe/genjavadoc/NeedsJavaSig.scala

@@ -0,0 +1,20 @@
+package com.typesafe.genjavadoc
+import scala.reflect.internal.util.Position
+import scala.tools.nsc.doc.ScaladocSyntaxAnalyzer
+
+trait Comments extends BaseComments { this: TransformCake =>
+  val parser = new ScaladocSyntaxAnalyzer[global.type](global) {
+    val runsAfter = List[String]()
+    val runsRightAfter = None
+  }
+
+  override def parseComments(): Unit =
+    new parser.ScaladocUnitParser(unit, Nil) {
+      override def newScanner = new parser.ScaladocUnitScanner(unit, Nil) {
+        override def registerDocComment(str: String, pos: Position) = {
+          super.registerDocComment(str, pos)
+          comments += pos -> Comment(pos, str)
+        }
+      }
+    }.parse()
+}

plugin/src/main/scala-2.13/com/typesafe/genjavadoc/Comments.scala

@@ -0,0 +1,44 @@
+package com.typesafe.genjavadoc
+
+trait NeedsJavaSig { this: TransformCake =>
+
+  import global._
+  import definitions._
+
+  def needsJavaSig(tp: Type): Boolean =
+    !settings.Ynogenericsig.value && NeedsSigCollector.collect(tp)
+
+  private object NeedsSigCollector extends TypeCollector(false) {
+    private def rebindInnerClass(pre: Type, cls: Symbol): Type =
+      if (cls.owner.isClass) cls.owner.tpe else pre // why not cls.isNestedClass?
+    // the rest is mostly copy and paste from NeedsSigCollector in nsc/transform/Erasure.scala
+    @annotation.tailrec
+    private[this] def untilApply(ts: List[Type]): Unit =
+      if (! ts.isEmpty && ! result) { apply(ts.head) ; untilApply(ts.tail) }
+    override def apply(tp: Type): Unit = {
+      if (!result) {
+        tp match {
+          case st: SubType =>
+            apply(st.supertype)
+          case TypeRef(pre, sym, args) =>
+            if (sym == ArrayClass) untilApply(args)
+            else if (sym.isTypeParameterOrSkolem || sym.isExistentiallyBound || !args.isEmpty) result = true
+            else if (sym.isClass) apply(rebindInnerClass(pre, sym)) // #2585
+            else if (!sym.owner.isPackageClass) apply(pre)
+          case PolyType(_, _) | ExistentialType(_, _) =>
+            result = true
+          case RefinedType(parents, _) =>
+            untilApply(parents)
+          case ClassInfoType(parents, _, _) =>
+            untilApply(parents)
+          case at: AnnotatedType =>
+            apply(at.underlying)
+          case _ =>
+            tp.foldOver(this)
+        }
+      }
+    }
+  }
+
+}
+