Address review comments

Author: allanrenucci

compiler/src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -21,19 +21,12 @@ class JavaPlatform extends Platform {
   }
 
   // The given symbol is a method with the right name and signature to be a runnable java program.
-  def isJavaMainMethod(sym: SymDenotation)(implicit ctx: Context) =
+  def isMainMethod(sym: SymDenotation)(implicit ctx: Context) =
     (sym.name == nme.main) && (sym.info match {
       case MethodTpe(_, defn.ArrayOf(el) :: Nil, restpe) => el =:= defn.StringType && (restpe isRef defn.UnitClass)
       case _ => false
     })
 
-  // The given class has a main method.
-  def hasJavaMainMethod(sym: Symbol)(implicit ctx: Context): Boolean =
-    (sym.info member nme.main).hasAltWith {
-      case x: SymDenotation => isJavaMainMethod(x)
-      case _ => false
-    }
-
   /** Update classpath with a substituted subentry */
   def updateClassPath(subst: Map[ClassPath, ClassPath]): Unit = currentClassPath.get match {
     case AggregateClassPath(entries) =>

compiler/src/dotty/tools/dotc/config/Platform.scala

@@ -10,6 +10,8 @@ package config
 import io.{ClassPath, AbstractFile}
 import core.Contexts._, core.Symbols._
 import core.SymbolLoader
+import core.SymDenotations.SymDenotation
+import core.StdNames.nme
 
 /** The platform dependent pieces of Global.
  */
@@ -35,5 +37,15 @@ abstract class Platform {
 
   /** Create a new class loader to load class file `bin` */
   def newClassLoader(bin: AbstractFile)(implicit ctx: Context): SymbolLoader
+
+  /** The given symbol is a method with the right name and signature to be a runnable program. */
+  def isMainMethod(sym: SymDenotation)(implicit ctx: Context): Boolean
+
+  /** The given class has a main method. */
+  final def hasMainMethod(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.info.member(nme.main).hasAltWith {
+      case x: SymDenotation => isMainMethod(x)
+      case _ => false
+    }
 }
 

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -228,20 +228,9 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
       name, acc, modifiers, anns, defType, api.SafeLazy.strict(selfType), api.SafeLazy.strict(structure), Constants.emptyStringArray,
       childrenOfSealedClass, topLevel, tparams)
 
-    // if (name.toString.contains("DottyPredef")) {
-    //   println("sym: " + sym)
-    //   println("name: " + name)
-    //   ctx.atPhase(ctx.flattenPhase.next) { implicit ctx =>
-    //     println("flatten: " + sym.fullName.toString)
-    //     println("flattenm: " + sym.fullName.mangledString)
-    //   }
-    //   println("flattenx: " + toDenot(sym.binaryName.toString)
-    // }
-
     allNonLocalClassesInSrc += cl
 
-    val javaPlatform = ctx.platform.asInstanceOf[JavaPlatform]
-    if (sym.isStatic && defType == DefinitionType.Module && javaPlatform.hasJavaMainMethod(sym)) {
+    if (sym.isStatic && defType == DefinitionType.Module && ctx.platform.hasMainMethod(sym)) {
       _mainClasses += name
     }
 

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -161,6 +161,7 @@ object ExtractDependencies {
 
 private case class ClassDependency(from: Symbol, to: Symbol, context: DependencyContext)
 
+/** An object that maintain the set of used names from within a class */
 private final class UsedNamesInClass {
   private val _names = new mutable.HashMap[Name, EnumSet[UseScope]]
   def names: collection.Map[Name, EnumSet[UseScope]] = _names

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

@@ -70,8 +70,7 @@ class CollectEntryPoints extends MiniPhase {
     }
     def precise(implicit ctx: Context) = {
       val companion = sym.companionClass //sym.asClass.linkedClassOfClass
-      val javaPlatform = ctx.platform.asInstanceOf[JavaPlatform]
-      if (javaPlatform.hasJavaMainMethod(companion))
+      if (ctx.platform.hasMainMethod(companion))
         failNoForwarder("companion contains its own main method")
       else if (companion.exists && companion.info.member(nme.main).exists)
       // this is only because forwarders aren't smart enough yet
@@ -80,7 +79,7 @@ class CollectEntryPoints extends MiniPhase {
         failNoForwarder("companion is a trait")
       // Now either succeed, or issue some additional warnings for things which look like
       // attempts to be java main methods.
-      else (possibles exists (x => javaPlatform.isJavaMainMethod(x.symbol))) || {
+      else (possibles exists (x => ctx.platform.isMainMethod(x.symbol))) || {
         possibles exists {
           m =>
             m.symbol.info match {
@@ -90,7 +89,7 @@ class CollectEntryPoints extends MiniPhase {
                 if (t.resultType :: t.paramInfos exists (_.typeSymbol.isAbstractType))
                   fail("main methods cannot refer to type parameters or abstract types.", m.symbol.pos)
                 else
-                  javaPlatform.isJavaMainMethod(m.symbol) || fail("main method must have exact signature (Array[String])Unit", m.symbol.pos)
+                  ctx.platform.isMainMethod(m.symbol) || fail("main method must have exact signature (Array[String])Unit", m.symbol.pos)
               case tp =>
                 fail(s"don't know what this is: $tp", m.symbol.pos)
             }