minor reflection related refactor

2 files changed, 17 insertions, 30 deletions

diff --git a/stage1/Stage1Lib.scala b/stage1/Stage1Lib.scala
index 3ffc878..55c9234 100644
--- a/stage1/Stage1Lib.scala
+++ b/stage1/Stage1Lib.scala
@@ -79,28 +79,11 @@ class Stage1Lib( logger: Logger ) extends
     }
   }
 
-  /*
-  // ========== compilation / execution ==========
-  // TODO: move classLoader first
-  def runMain( className: String, args: Seq[String], classLoader: ClassLoader ): ExitCode = {
-    import java.lang.reflect.Modifier
-    logger.run(s"Running $className.main($args) with classLoader: " ++ classLoader.toString)
-    trapExitCode{
-      /*
-      val cls = classLoader.loadClass(className)
-      discoverCbtMain( cls ) orElse discoverMain( cls ) getOrElse (
-        throw new NoSuchMethodException( "No main method found in " ++ cbt )
-      ).apply( arg.toVector )*/
-      ExitCode.Success
-    }
-  }
-  */
-
-  def discoverCbtMainForced( cls: Class[_] ): cbt.reflect.StaticMethod[Context, ExitCode] =
-    discoverStaticMethodForced[Context, ExitCode]( cls, "cbtMain" )
+  def getCbtMain( cls: Class[_] ): cbt.reflect.StaticMethod[Context, ExitCode] =
+    findStaticMethodForced[Context, ExitCode]( cls, "cbtMain" )
 
-  def discoverCbtMain( cls: Class[_] ): Option[cbt.reflect.StaticMethod[Context, ExitCode]] =
-    discoverStaticMethod[Context, ExitCode]( cls, "cbtMain" )
+  def findCbtMain( cls: Class[_] ): Option[cbt.reflect.StaticMethod[Context, ExitCode]] =
+    findStaticMethod[Context, ExitCode]( cls, "cbtMain" )
 
   /** shows an interactive dialogue in the shell asking the user to pick one of many choices */
   def pickOne[T]( msg: String, choices: Seq[T] )( show: T => String ): Option[T] = {
diff --git a/stage1/resolver.scala b/stage1/resolver.scala
index 0e5d221..be4d278 100644
--- a/stage1/resolver.scala
+++ b/stage1/resolver.scala
@@ -77,24 +77,28 @@ trait DependencyImplementation extends Dependency{
     )
   }
   */
-  def flatClassLoader: Boolean = false
 
-  def runMain( className: String, args: Seq[String] ): ExitCode = lib.trapExitCode{
-    lib.runMain( classLoader.loadClass( className ), args )
+  def runMain( className: String, args: Seq[String] ): ExitCode = {
+      lib.getMain( classLoader.loadClass( className ) )( args )
   }
 
-  def runMain( args: Seq[String] ): ExitCode = lib.trapExitCode{
-    mainMethod.getOrElse(
+  def runMain( args: Seq[String] ): ExitCode = {
+    val c = mainClass.getOrElse(
       throw new RuntimeException( "No main class found in " + this )
-    )( args )
+    )
+    runMain( c.getName, args )
   }
 
-  def mainMethod = lib.pickOne( "Which one do you want to run?", mainMethods )( _.name )
+  def mainClass = lib.pickOne(
+    "Which one do you want to run?",
+    classes.filter( lib.findMain(_).nonEmpty )
+  )( _.name.stripSuffix( "$" ) )
 
   def classes = exportedClasspath.files.flatMap(
-    lib.iterateClasses( _, classLoader, false )
+    lib.topLevelClasses( _, classLoader, false )
   )
-  def mainMethods = classes.flatMap( lib.discoverMain )
+
+  def flatClassLoader: Boolean = false
 
   def classLoader: ClassLoader = taskCache[DependencyImplementation]( "classLoader" ).memoize{
     if( flatClassLoader ){