More fixes to reflection and code lifting.

10 files changed, 75 insertions, 31 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index 7bf646a118..2c51ca0db5 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -666,7 +666,10 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     private def getModuleOrClass(path: Name, len: Int): Symbol = {
       val point = path lastPos('.', len - 1)
-      val owner = if (point > 0) getModuleOrClass(path.toTermName, point) else RootClass
+      val owner =
+        if (point > 0) getModuleOrClass(path.toTermName, point)
+        else if (path.isTypeName) EmptyPackageClass
+        else RootClass
       val name = path subName (point + 1, len)
       val sym = owner.info member name
       val result = if (path.isTermName) sym.suchThat(_ hasFlag MODULE) else sym
diff --git a/src/compiler/scala/reflect/internal/Importers.scala b/src/compiler/scala/reflect/internal/Importers.scala
index 32238289de..6d672d9263 100644
--- a/src/compiler/scala/reflect/internal/Importers.scala
+++ b/src/compiler/scala/reflect/internal/Importers.scala
@@ -23,7 +23,6 @@ trait Importers { self: SymbolTable =>
         val mypos = importPosition(sym.pos)
         val myname = importName(sym.name)
         def linkReferenced(mysym: TermSymbol, x: from.TermSymbol, op: from.Symbol => Symbol): Symbol = {
-          println("link referenced " + mysym + " " + x.referenced)
           symMap(x) = mysym
           mysym.referenced = op(x.referenced)
           mysym
@@ -124,7 +123,6 @@ trait Importers { self: SymbolTable =>
                 "import failure: cannot determine parameter "+sym+" (#"+sym.paramPos+") in "+
                 myowner+typeParamsString(myowner.rawInfo)+"\n original symbol was: "+
                 sym.owner+from.typeParamsString(sym.owner.info))
-            println(myowner.rawInfo)
             myowner.typeParams(sym.paramPos)
           } else
             doImport(sym)
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala
index 81063a63b3..f3d335d30e 100644
--- a/src/compiler/scala/reflect/runtime/JavaToScala.scala
+++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala
@@ -32,6 +32,12 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
     val global: JavaToScala.this.type = self
   }
 
+  /** Paul: It seems the default class loader does not pick up root classes, whereas the system classloader does.
+   *  Can you check with your newly acquired classloader fu whether this implementation makes sense?
+   */
+  def javaClass(path: String): jClass[_] =
+    jClass.forName(path, false, java.lang.ClassLoader.getSystemClassLoader)
+
 
   /**
    * Generate types for top-level Scala root class and root companion object
@@ -170,7 +176,6 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
         (if (jModifier.isStatic(mods)) module.moduleClass else clazz).info.decls enter sym
 
       for (jinner <- jclazz.getDeclaredClasses) {
-        println("... entering "+jinner)
         enter(jclassAsScala(jinner, clazz), jinner.getModifiers)
       }
 
@@ -223,10 +228,10 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
       methodToScala(jclazz.getEnclosingMethod) orElse constrToScala(jclazz.getEnclosingConstructor)
     else if (jclazz.isPrimitive || jclazz.isArray)
       ScalaPackageClass
-    else {
-      assert(jclazz.getPackage != null, jclazz)
+    else if (jclazz.getPackage != null)
       packageToScala(jclazz.getPackage)
-    }
+    else
+      EmptyPackageClass
   }
 
   /**
@@ -305,7 +310,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    *  this one bypasses the cache.
    */
   def makeScalaPackage(fullname: String): Symbol = {
-    println("make scala pkg "+fullname)
+    info("make scala pkg "+fullname)
     val split = fullname lastIndexOf '.'
     val owner = if (split > 0) packageNameToScala(fullname take split) else RootClass
     assert(owner.isModuleClass, owner+" when making "+fullname)
@@ -318,7 +323,6 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
       owner.info.decls enter pkg
     } else if (!pkg.isPackage)
       throw new ReflectError(pkg+" is not a package")
-    println(" = "+pkg+"/"+pkg.moduleClass)
     pkg.moduleClass
   }
 
diff --git a/src/compiler/scala/reflect/runtime/Loaders.scala b/src/compiler/scala/reflect/runtime/Loaders.scala
index bcd80ca557..28f528b965 100644
--- a/src/compiler/scala/reflect/runtime/Loaders.scala
+++ b/src/compiler/scala/reflect/runtime/Loaders.scala
@@ -35,7 +35,7 @@ trait Loaders { self: SymbolTable =>
       assert(sym == clazz || sym == module || sym == module.moduleClass)
 //      try {
       atPhaseNotLaterThan(picklerPhase) {
-        unpickleClass(clazz, module, jClass.forName(clazz.fullName))
+        unpickleClass(clazz, module, javaClass(clazz.fullName))
 //      } catch {
 //        case ex: ClassNotFoundException => makePackage()
 //        case ex: NoClassDefFoundError => makePackage()
@@ -102,16 +102,21 @@ trait Loaders { self: SymbolTable =>
         e
       else if (invalidClassName(name) || (negatives contains name))
         null
-      else try {
-        jClass.forName(pkgClass.fullName + "." + name)
-        val (clazz, module) = createClassModule(pkgClass, name.toTypeName, new TopClassCompleter(_, _))
-        info("created "+module+"/"+module.moduleClass+" in "+pkgClass)
-        lookupEntry(name)
-      } catch {
-        case (_: ClassNotFoundException) | (_: NoClassDefFoundError) =>
-          info("*** not found : "+pkgClass.fullName + "." + name)
-          negatives += name
-          null
+      else {
+        val path =
+          if (pkgClass.isEmptyPackageClass) name.toString
+          else pkgClass.fullName + "." + name
+        try {
+          javaClass(path)
+          val (clazz, module) = createClassModule(pkgClass, name.toTypeName, new TopClassCompleter(_, _))
+          info("created "+module+"/"+module.moduleClass+" in "+pkgClass)
+          lookupEntry(name)
+        } catch {
+          case (_: ClassNotFoundException) | (_: NoClassDefFoundError) =>
+            info("*** not found : "+path)
+            negatives += name
+            null
+        }
       }
     }
   }
diff --git a/src/compiler/scala/reflect/runtime/Mirror.scala b/src/compiler/scala/reflect/runtime/Mirror.scala
index 14604fbd52..faec0a7783 100644
--- a/src/compiler/scala/reflect/runtime/Mirror.scala
+++ b/src/compiler/scala/reflect/runtime/Mirror.scala
@@ -8,9 +8,11 @@ import java.lang.reflect.Array
  */
 class Mirror extends Universe with RuntimeTypes with TreeBuildUtil with ToolBoxes with api.Mirror {
 
+  definitions.init()
+
   import definitions._
 
-  def classWithName(name: String): Symbol = classToScala(java.lang.Class.forName(name))
+  def classWithName(name: String): Symbol = classToScala(javaClass(name))
   def getClass(obj: AnyRef): Symbol = classToScala(obj.getClass)
   def getType(obj: AnyRef): Type = typeToScala(obj.getClass)
   // to do add getClass/getType for instances of primitive types, probably like this:
diff --git a/src/compiler/scala/reflect/runtime/ScalaToJava.scala b/src/compiler/scala/reflect/runtime/ScalaToJava.scala
index f6e6087bf9..db8658d30c 100644
--- a/src/compiler/scala/reflect/runtime/ScalaToJava.scala
+++ b/src/compiler/scala/reflect/runtime/ScalaToJava.scala
@@ -43,7 +43,7 @@ trait ScalaToJava extends ConversionUtil { self: SymbolTable =>
     else if (clazz == ArrayClass)
       noClass
     else if (clazz.owner.isPackageClass)
-      jClass.forName(clazz.fullName)
+      javaClass(clazz.fullName)
     else if (clazz.owner.isClass)
       classToJava(clazz.owner)
         .getDeclaredClasses
diff --git a/src/compiler/scala/reflect/runtime/ToolBoxes.scala b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
index d5a0e29b02..cc40d8ca43 100644
--- a/src/compiler/scala/reflect/runtime/ToolBoxes.scala
+++ b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
@@ -24,7 +24,7 @@ trait ToolBoxes extends { self: Universe =>
     lazy val exporter = importer.reverse
 
     def typeCheck(tree: reflect.mirror.Tree, expectedType: reflect.mirror.Type): reflect.mirror.Tree = {
-      println("typing "+tree+", pt = "+expectedType)
+      if (compiler.settings.verbose.value) println("typing "+tree+", pt = "+expectedType)
       val run = new compiler.Run
       compiler.phase = run.refchecksPhase
       val ctree: compiler.Tree = importer.importTree(tree.asInstanceOf[Tree])
@@ -36,8 +36,13 @@ trait ToolBoxes extends { self: Universe =>
     def typeCheck(tree: reflect.mirror.Tree): reflect.mirror.Tree =
       typeCheck(tree, WildcardType.asInstanceOf[reflect.mirror.Type])
 
-    def show(tree: reflect.mirror.Tree): String = {
-      importer.importTree(tree.asInstanceOf[Tree]).toString
+    def showAttributed(tree: reflect.mirror.Tree): String = {
+      val saved = compiler.settings.printtypes.value
+      try {
+        compiler.settings.printtypes.value = true
+        importer.importTree(tree.asInstanceOf[Tree]).toString
+      } finally
+        compiler.settings.printtypes.value = saved
     }
   }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/transform/LiftCode.scala b/src/compiler/scala/tools/nsc/transform/LiftCode.scala
index 2239bfca65..7b4b583a10 100644
--- a/src/compiler/scala/tools/nsc/transform/LiftCode.scala
+++ b/src/compiler/scala/tools/nsc/transform/LiftCode.scala
@@ -298,10 +298,12 @@ abstract class LiftCode extends Transform with TypingTransformers {
       private def reifyTree(tree: Tree): Tree = tree match {
         case EmptyTree =>
           reifyCaseObject(tree)
-        case tree @ This(_) if !(boundSyms contains tree.symbol) =>
+        case This(_) if !(boundSyms contains tree.symbol) =>
           reifyFree(tree)
-        case tree @ Ident(_) if !(boundSyms contains tree.symbol) =>
+        case Ident(_) if !(boundSyms contains tree.symbol) =>
           reifyFree(tree)
+        case TypeTree() if (tree.tpe != null) =>
+          mirrorCall("TypeTree", reifyType(tree.tpe))
         case _ =>
           if (tree.isDef) boundSyms += tree.symbol
           reifyCaseClassInstance(tree.asInstanceOf[Product])
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 0f6f3c93e1..d1ba2df815 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -712,8 +712,7 @@ trait Typers extends Modes with Adaptations {
      *  (11) Widen numeric literals to their expected type, if necessary
      *  (12) When in mode EXPRmode, convert E to { E; () } if expected type is scala.Unit.
      *  (13) When in mode EXPRmode, apply AnnotationChecker conversion if expected type is annotated.
-     *  (14) When in more EXPRmode, convert E to Code.lift(E) if expected type is Code[_]
-     *  (15) When in mode EXPRmode, apply a view
+     *  (14) When in mode EXPRmode, apply a view
      *  If all this fails, error
      */
     protected def adapt(tree: Tree, mode: Int, pt: Type, original: Tree = EmptyTree): Tree = {
@@ -972,8 +971,6 @@ trait Typers extends Modes with Adaptations {
                       new ApplyImplicitView(coercion, List(tree)) setPos tree.pos, mode, pt)
                   }
                 }
-                if (isCodeType(pt) && !isCodeType(tree.tpe) && !tree.tpe.isError)
-                  return adapt(lifted(tree), mode, pt, original)
               }
               if (settings.debug.value) {
                 log("error tree = " + tree)
diff --git a/src/partest/scala/tools/partest/utils/CodeTest.scala b/src/partest/scala/tools/partest/utils/CodeTest.scala
new file mode 100644
index 0000000000..96a20b7fd5
--- /dev/null
+++ b/src/partest/scala/tools/partest/utils/CodeTest.scala
@@ -0,0 +1,28 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala Parallel Testing               **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+
+package scala.tools.partest
+package utils
+
+import scala.reflect.Code
+import reflect.runtime.Mirror.ToolBox
+import scala.tools.nsc.reporters._
+import scala.tools.nsc.Settings
+
+/** Runner for testing code tree liftingg
+ */
+object CodeTest {
+  def apply[T](code: Code[T], args: Array[String]) = {
+    println("testing: "+code.tree)
+    val reporter = new ConsoleReporter(new Settings)
+    val toolbox = new ToolBox(reporter, args mkString " ")
+    val ttree = toolbox.typeCheck(code.tree, code.manifest.tpe)
+    println("result = " + toolbox.showAttributed(ttree))
+  }
+}