More fixes/debug code for reflection.

6 files changed, 43 insertions, 12 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index 533549fdbf..0f4485f1b8 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -673,9 +673,10 @@ trait Definitions extends reflect.api.StandardDefinitions {
       var i = 0
       var j = fullname.pos('.', i)
       while (j < fullname.length) {
+        val sym0 = sym //DEBUG
         sym = sym.info.member(fullname.subName(i, j))
-        // if (sym == NoSymbol)
-        //   println("no member "+fullname.subName(i, j)+" found in "+sym0+sym0.info.getClass+" "+sym0.info.typeSymbol.info.getClass)
+        if (sym == NoSymbol)
+          println("no member "+fullname.subName(i, j)+" found in "+sym0+sym0.info.getClass+" "+sym0.info.typeSymbol.info.getClass)
         i = j + 1
         j = fullname.pos('.', i)
       }
@@ -683,7 +684,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
         if (module) sym.info.member(fullname.subName(i, j)).suchThat(_ hasFlag MODULE)
         else sym.info.member(fullname.subName(i, j).toTypeName)
       if (result == NoSymbol) {
-      //   println("no member "+fullname.subName(i, j)+" found in "+sym+" "+module)
+        println("no member "+fullname.subName(i, j)+" found in "+sym+" "+module+" "+sym.info.getClass)
         if (settings.debug.value)
           { log(sym.info); log(sym.info.members) }//debug
         throw new MissingRequirementError((if (module) "object " else "class ") + fullname)
diff --git a/src/compiler/scala/reflect/internal/Scopes.scala b/src/compiler/scala/reflect/internal/Scopes.scala
index 9cd67375ac..43d429180b 100644
--- a/src/compiler/scala/reflect/internal/Scopes.scala
+++ b/src/compiler/scala/reflect/internal/Scopes.scala
@@ -80,6 +80,8 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
       clone
     }
 
+    def mkScope: Scope = new Scope()
+
     /** is the scope empty? */
     override def isEmpty: Boolean = elems eq null
 
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 620910caa8..2af26c7ee7 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -54,7 +54,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     private var rawpos = initPos
     val id = { ids += 1; ids } // identity displayed when -uniqid
-    //assert(id != 34, initName)
+    //assert(id != 3204, initName)
 
     var validTo: Period = NoPeriod
 
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala
index 87551019c0..a01595fad1 100644
--- a/src/compiler/scala/reflect/runtime/JavaToScala.scala
+++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala
@@ -97,7 +97,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    */
   private class TypeParamCompleter(jtvar: jTypeVariable[_ <: GenericDeclaration]) extends LazyType {
     override def complete(sym: Symbol) = {
-      sym setInfo TypeBounds(NothingClass.tpe, lub(jtvar.getBounds.toList map typeToScala))
+      sym setInfo TypeBounds(NothingClass.tpe, glb(jtvar.getBounds.toList map typeToScala map objToAny))
     }
   }
 
@@ -253,11 +253,13 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    *  this one bypasses the cache.
    */
   private def makeScalaPackage(fullname: String): Symbol = {
+    println("make scala pkg "+fullname)
     val split = fullname lastIndexOf '.'
     val owner = if (split > 0) packageNameToScala(fullname take split) else RootClass
-    assert(owner.isModuleClass)
+    assert(owner.isModuleClass, owner+" when making "+fullname)
     val name = fullname drop (split + 1)
     val pkg = owner.info decl newTermName(name)
+    println(" = "+pkg+"/"+pkg.moduleClass)
     pkg.moduleClass
   }
 
@@ -327,7 +329,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
         val tparam = owner.newExistential(NoPosition, newTypeName("T$" + tparams.length))
           .setInfo(TypeBounds(
             lub(jwild.getLowerBounds.toList map typeToScala),
-            glb(scala.tools.nsc.util.trace("glb args")(jwild.getUpperBounds.toList) map typeToScala)))
+            glb(scala.tools.nsc.util.trace("glb args")(jwild.getUpperBounds.toList) map typeToScala map objToAny)))
         tparams += tparam
         typeRef(NoPrefix, tparam, List())
       case _ =>
@@ -386,6 +388,10 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
     field
   }
 
+  private def setMethType(meth: Symbol, tparams: List[Symbol], paramtpes: List[Type], restpe: Type) = {
+    meth setInfo polyType(tparams, MethodType(meth.owner.newSyntheticValueParams(paramtpes map objToAny), restpe))
+  }
+
   /**
    * The Scala method that corresponds to given Java method without taking
    *  Scala pickling info into account.
@@ -399,7 +405,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
     val tparams = jmeth.getTypeParameters.toList map createTypeParameter
     val paramtpes = jmeth.getGenericParameterTypes.toList map typeToScala
     val resulttpe = typeToScala(jmeth.getGenericReturnType)
-    meth setInfo polyType(tparams, MethodType(clazz.newSyntheticValueParams(paramtpes), resulttpe))
+    setMethType(meth, tparams, paramtpes, resulttpe)
     copyAnnotations(meth, jmeth)
     meth
   }
@@ -417,6 +423,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
       .setFlag(toScalaFlags(jconstr.getModifiers, isClass = false) | JAVA)
     val tparams = jconstr.getTypeParameters.toList map createTypeParameter
     val paramtpes = jconstr.getGenericParameterTypes.toList map typeToScala
+    setMethType(meth, tparams, paramtpes, clazz.tpe)
     meth setInfo polyType(tparams, MethodType(clazz.newSyntheticValueParams(paramtpes), clazz.tpe))
     copyAnnotations(meth, jconstr)
     meth
diff --git a/src/compiler/scala/reflect/runtime/Loaders.scala b/src/compiler/scala/reflect/runtime/Loaders.scala
index 54803a6211..d7cdd3c684 100644
--- a/src/compiler/scala/reflect/runtime/Loaders.scala
+++ b/src/compiler/scala/reflect/runtime/Loaders.scala
@@ -10,7 +10,7 @@ trait Loaders { self: SymbolTable =>
   /** The lazy type for root.
    */
   override val rootLoader = new LazyType {
-    override def complete(sym: Symbol) = sym setInfo new PackageType(definitions.RootClass)
+    override def complete(sym: Symbol) = sym setInfo newPackageType(definitions.RootClass)
   }
 
   /** The standard completer for top-level classes
@@ -22,7 +22,7 @@ trait Loaders { self: SymbolTable =>
    */
   class TopClassCompleter(clazz: Symbol, module: Symbol) extends LazyType {
     def makePackage() {
-      val ptpe = new PackageType(module.moduleClass)
+      val ptpe = newPackageType(module.moduleClass)
       for (sym <- List(clazz, module, module.moduleClass)) {
         sym setFlag Flags.PACKAGE
         sym setInfo ptpe
@@ -80,7 +80,8 @@ trait Loaders { self: SymbolTable =>
    *  a TopClassCompleter type. When any of the two symbols is forced via info,
    *  the TopClassCompleter will sort things out.
    */
-  class PackageType(pkg: Symbol) extends ClassInfoType(List(), newScope, pkg) {
+  def newPackageType(pkg: Symbol) = new ClassInfoType(List(), new PackageScope(pkg), pkg) {
+    /*
     override def decl(name: Name): Symbol =
       (decls lookup name) orElse {
         assert(this eq pkg.info, this+" "+pkg.info)
@@ -92,6 +93,25 @@ trait Loaders { self: SymbolTable =>
     override def member(name: Name): Symbol = decl(name)
     override def findMember(name: Name, excludedFlags: Long, requiredFlags: Long, stableOnly: Boolean) =
       member(name).filter (m => m.hasAllFlags(requiredFlags) && !m.hasFlag(excludedFlags))
+*/
     override def safeToString = pkg.toString
   }
-}
\ No newline at end of file
+
+  class PackageScope(pkg: Symbol) extends Scope {
+    override def lookupEntry(name: Name): ScopeEntry = {
+      val e = super.lookupEntry(name)
+      if (e != null)
+        e
+      else try {
+        if (name.isTypeName) jClass.forName(pkg.fullName + "." + name)
+        val (clazz, module) = createClassModule(pkg, name.toTypeName, new TopClassCompleter(_, _))
+        println("created "+module+"/"+module.moduleClass+" in "+pkg+", scope = "+(this map (_.name)))
+        lookupEntry(name)
+      } catch {
+        case ex: ClassNotFoundException =>
+          println("not found: "+pkg.fullName + "." + name)
+          null
+      }
+    }
+  }
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 794f244309..94179c6cac 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3779,6 +3779,7 @@ trait Typers extends Modes with Adaptations {
           while (defSym == NoSymbol && cx != NoContext) {
             currentRun.compileSourceFor(context.asInstanceOf[analyzer.Context], name)
             pre = cx.enclClass.prefix
+            if (name.toString == "Console") println("looking in "+cx.owner)
             defEntry = cx.scope.lookupEntry(name)
             if ((defEntry ne null) && qualifies(defEntry.sym)) {
               defSym = defEntry.sym