Shared backend

bin/dotc

@@ -4,8 +4,9 @@
 
 
 # Configuration
-SCALA_VERSION=2.11.1
+SCALA_VERSION=2.11.4
 SCALA_BINARY_VERSION=2.11
+SCALA_COMPILER_VERSION=2.11.5-20141212-151631-beaa78b033
 DOTTY_VERSION=0.1
 bootcp=true
 default_java_opts="-Xmx768m -Xms768m"
@@ -62,12 +63,18 @@ if [ "$SCALA_REFLECT_JAR" == "" ]
 then  
   SCALA_REFLECT_JAR=$HOME/.ivy2/cache/org.scala-lang/scala-reflect/jars/scala-reflect-$SCALA_VERSION.jar
 fi
+if [ "$SCALA_COMPILER_JAR" == "" ]
+then
+  SCALA_COMPILER_JAR=$HOME/.ivy2/cache/me.d-d/scala-compiler/jars/scala-compiler-$SCALA_COMPILER_VERSION.jar
+fi
 
-if [ ! -f "$SCALA_LIBRARY_JAR" -o ! -f "$SCALA_REFLECT_JAR" ]
+if [ ! -f "$SCALA_LIBRARY_JAR" -o ! -f "$SCALA_REFLECT_JAR"  -o ! -f "$SCALA_COMPILER_JAR" ]
 then
   echo To use this script please set 
   echo SCALA_LIBRARY_JAR to point to scala-library-$SCALA_VERSION.jar "(currently $SCALA_LIBRARY_JAR)"
   echo SCALA_REFLECT_JAR to point to scala-reflect-$SCALA_VERSION.jar "(currently $SCALA_REFLECT_JAR)"
+  echo SCALA_COMPILER_JAR to point to scala-compiler-$SCALA_VERSION.jar with bcode patches "(currently $SCALA_COMPILER_JAR)"
+
 fi
 
 ifdebug () {
@@ -156,7 +163,7 @@ trap onExit INT
 # to java to suppress "." from materializing.
 classpathArgs () {
   if [[ -n $bootcp ]]; then
-echo "-Xbootclasspath/a:$SCALA_LIBRARY_JAR:$SCALA_REFLECT_JAR:$MAIN_JAR -classpath $MAIN_JAR"
+echo "-Xbootclasspath/a:$SCALA_LIBRARY_JAR:$SCALA_REFLECT_JAR:$SCALA_COMPILER_JAR:$MAIN_JAR -classpath $MAIN_JAR"
   else
 echo "-classpath $SCALA_LIBRARY_JAR:$SCALA_REFLECT_JAR:$MAIN_JAR"
   fi

build.sbt

@@ -1,7 +1,7 @@
 
 name := "dotty"
 
-scalaVersion in Global := "2.11.1"
+scalaVersion in Global := "2.11.4"
 
 version in Global := "0.1-SNAPSHOT"
 

project/Build.scala

@@ -30,7 +30,8 @@ object DottyBuild extends Build {
 
     // get reflect and xml onboard
     libraryDependencies ++= Seq("org.scala-lang" % "scala-reflect" % scalaVersion.value,
-                                "org.scala-lang.modules" %% "scala-xml" % "1.0.1"),
+                                "org.scala-lang.modules" %% "scala-xml" % "1.0.1",
+                                "me.d-d" % "scala-compiler" % "2.11.5-20141212-151631-beaa78b033"),
 
     // get junit onboard
     libraryDependencies += "com.novocode" % "junit-interface" % "0.11-RC1" % "test",
@@ -53,7 +54,7 @@ object DottyBuild extends Build {
 
     // http://grokbase.com/t/gg/simple-build-tool/135ke5y90p/sbt-setting-jvm-boot-paramaters-for-scala
     javaOptions <++= (managedClasspath in Runtime, packageBin in Compile) map { (attList, bin) =>
-       // put the Scala {library, reflect, compiler} in the classpath
+       // put the Scala {library, reflect} in the classpath
        val path = for {
          file <- attList.map(_.data)
          path = file.getAbsolutePath

src/dotty/tools/backend/jvm/CollectEntryPoints.scala

@@ -0,0 +1,120 @@
+package dotty.tools.backend.jvm
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Types
+import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, TreeTransform, MiniPhase, MiniPhaseTransform}
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc
+import dotty.tools.dotc.backend.jvm.DottyPrimitives
+import dotty.tools.dotc.core.Flags.FlagSet
+import dotty.tools.dotc.transform.Erasure
+import dotty.tools.dotc.transform.SymUtils._
+import java.io.{File => JFile}
+
+import scala.collection.generic.Clearable
+import scala.collection.mutable
+import scala.reflect.ClassTag
+import scala.reflect.internal.util.WeakHashSet
+import scala.reflect.io.{Directory, PlainDirectory, AbstractFile}
+import scala.tools.asm.{ClassVisitor, FieldVisitor, MethodVisitor}
+import scala.tools.nsc.backend.jvm.{BCodeHelpers, BackendInterface}
+import dotty.tools.dotc.core._
+import Periods._
+import SymDenotations._
+import Contexts._
+import Types._
+import Symbols._
+import Denotations._
+import Phases._
+import java.lang.AssertionError
+import dotty.tools.dotc.util.Positions.Position
+import Decorators._
+import tpd._
+import StdNames.nme
+
+/**
+ * Created by dark on 26/11/14.
+ */
+class CollectEntryPoints extends MiniPhaseTransform {
+  def phaseName: String = "Collect entry points"
+
+  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+    if((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntyPoint(tree.symbol)) {
+      ctx.genBCodePhase.asInstanceOf[GenBCode].registerEntryPoint(tree.symbol)
+    }
+    tree
+  }
+}
+
+object CollectEntryPoints{
+  def isJavaEntyPoint(sym: Symbol)(implicit ctx: Context): Boolean = {
+    import Types.MethodType
+    val d = ctx.definitions
+    val StringType = d.StringType
+    def isJavaMainMethod(sym: Symbol) = (sym.name == nme.main) && (toDenot(sym).info match {
+      case r@ MethodType(_, List(d.ArrayType(StringType))) => r.resultType eq d.UnitType
+      case _                            => false
+    })
+    // The given class has a main method.
+    def hasJavaMainMethod(sym: Symbol): Boolean =
+      (toDenot(sym).info member nme.main).alternatives exists(x => isJavaMainMethod(x.symbol))
+
+    def fail(msg: String, pos: Position = sym.pos) = {
+      ctx.warning(          sym.name +
+        s" has a main method with parameter type Array[String], but ${toDenot(sym).fullName} will not be a runnable program.\n  Reason: $msg",
+        sourcePos(sym.pos)
+        // TODO: make this next claim true, if possible
+        //   by generating valid main methods as static in module classes
+        //   not sure what the jvm allows here
+        // + "  You can still run the program by calling it as " + javaName(sym) + " instead."
+      )
+      false
+    }
+    def failNoForwarder(msg: String) = {
+      fail(s"$msg, which means no static forwarder can be generated.\n")
+    }
+    val possibles = if (sym.flags is Flags.Module) (toDenot(sym).info nonPrivateMember nme.main).alternatives else Nil
+    val hasApproximate = possibles exists { m =>
+      m.info match {
+        case MethodType(_, p :: Nil) =>
+          p.typeSymbol == defn.ArrayClass
+        case _                       => false
+      }
+    }
+    // At this point it's a module with a main-looking method, so either succeed or warn that it isn't.
+    hasApproximate && {
+      // Before erasure so we can identify generic mains.
+      {
+        // implicit val c = ctx.withPhase(ctx.erasurePhase)
+
+        val companion     = sym.asClass.moduleClass
+
+        if (hasJavaMainMethod(companion))
+          failNoForwarder("companion contains its own main method")
+        else if (toDenot(companion).info.member(nme.main) != NoDenotation)
+        // this is only because forwarders aren't smart enough yet
+          failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
+        else if (companion.flags is Flags.Trait)
+          failNoForwarder("companion is a trait")
+        // Now either succeeed, or issue some additional warnings for things which look like
+        // attempts to be java main methods.
+        else (possibles exists(x=> isJavaMainMethod(x.symbol))) || {
+          possibles exists { m =>
+            toDenot(m.symbol).info match {
+              case t:PolyType =>
+                fail("main methods cannot be generic.")
+              case t@MethodType(paramNames, paramTypes) =>
+                if (t.resultType :: paramTypes exists (_.typeSymbol.isAbstractType))
+                  fail("main methods cannot refer to type parameters or abstract types.", m.symbol.pos)
+                else
+                  isJavaMainMethod(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)
+            }
+          }
+        }
+      }
+    }
+  }
+}