Revert "Fixing inliner visibility issue."

This reverts commit 2820770.

Last minute change had unintended consequences.

Author: paulp

src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala

@@ -439,58 +439,62 @@ abstract class ClassfileParser {
 //    println("found: " + sym)
     sym
   }
-  
-  protected def lookupClass(name: Name) = {
-    val sym = name match {
-      case fulltpnme.RuntimeNothing => definitions.NothingClass
-      case fulltpnme.RuntimeNull    => definitions.NullClass
-      case _ =>
-        if (innerClasses contains name)   // check inner classes
-          innerClasses.classSymbol(innerClasses(name).externalName)
-        else if (name containsChar '.')   // qualified name
-          definitions.getClassIfDefined(name)
-        else                              // might be in the empty package
-          definitions.getMember(definitions.EmptyPackageClass, name.toTypeName)
-    }
-
-    sym orElse loadClassSymbol(name)
-  }
 
-  protected def loadClassSymbol(name: Name): Symbol = {
-    val file = global.classPath findSourceFile ("" +name) getOrElse {
-      warning("Class " + name + " not found - continuing with a stub.")
-      return NoSymbol.newClass(name.toTypeName)
-    }
-    val completer     = new global.loaders.ClassfileLoader(file)
-    var owner: Symbol = definitions.RootClass
-    var sym: Symbol   = NoSymbol
-    var ss: Name      = null
-    var start         = 0
-    var end           = name indexOf '.'
-
-    while (end > 0) {
-      ss = name.subName(start, end)
-      sym = owner.info.decls lookup ss
-      if (sym == NoSymbol) {
-        sym = owner.newPackage(ss) setInfo completer
-        sym.moduleClass setInfo completer
-        owner.info.decls enter sym
+  /** Return the class symbol of the given name. */
+  def classNameToSymbol(name: Name): Symbol = {
+    def loadClassSymbol(name: Name): Symbol = {
+      val file = global.classPath findSourceFile ("" +name) getOrElse {
+        warning("Class " + name + " not found - continuing with a stub.")
+        return NoSymbol.newClass(name.toTypeName)
+      }
+      val completer     = new global.loaders.ClassfileLoader(file)
+      var owner: Symbol = definitions.RootClass
+      var sym: Symbol   = NoSymbol
+      var ss: Name      = null
+      var start         = 0
+      var end           = name indexOf '.'
+
+      while (end > 0) {
+        ss = name.subName(start, end)
+        sym = owner.info.decls lookup ss
+        if (sym == NoSymbol) {
+          sym = owner.newPackage(ss) setInfo completer
+          sym.moduleClass setInfo completer
+          owner.info.decls enter sym
+        }
+        owner = sym.moduleClass
+        start = end + 1
+        end = name.indexOf('.', start)
       }
-      owner = sym.moduleClass
-      start = end + 1
-      end = name.indexOf('.', start)
+      ss = name.subName(0, start)
+      owner.info.decls lookup ss orElse {
+        sym = owner.newClass(ss.toTypeName) setInfoAndEnter completer
+        debuglog("loaded "+sym+" from file "+file)
+        sym
+      }
+    }
+
+    def lookupClass(name: Name) = try {
+      if (name.pos('.') == name.length)
+        definitions.getMember(definitions.EmptyPackageClass, name.toTypeName)
+      else
+        definitions.getClass(name) // see tickets #2464, #3756
+    } catch {
+      case _: FatalError => loadClassSymbol(name)
     }
-    ss = name.subName(0, start)
-    owner.info.decls lookup ss orElse {
-      sym = owner.newClass(ss.toTypeName) setInfoAndEnter completer
-      debuglog("loaded "+sym+" from file "+file)
-      sym
+
+    innerClasses.get(name) match {
+      case Some(entry) =>
+        //println("found inner class " + name)
+        val res = innerClasses.classSymbol(entry.externalName)
+        //println("\trouted to: " + res)
+        res
+      case None =>
+        //if (name.toString.contains("$")) println("No inner class: " + name + innerClasses + " while parsing " + in.file.name)
+        lookupClass(name)
     }
   }
 
-  /** Return the class symbol of the given name. */
-  def classNameToSymbol(name: Name): Symbol = lookupClass(name)
-
   var sawPrivateConstructor = false
 
   def parseClass() {

src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala

@@ -160,27 +160,34 @@ abstract class ICodeReader extends ClassfileParser {
   }
 
   override def classNameToSymbol(name: Name) = {
-    val sym = (
-      if (nme.isImplClassName(name)) {
-        val iface = lookupClass(nme.interfaceName(name))
-        log("forcing " + iface.owner + " at phase: " + phase + " impl: " + iface.implClass)
-        iface.owner.info // force the mixin type-transformer
-        lookupClass(name.toTypeName)
-      }
-      else if (nme.isModuleName(name)) {
-        val strippedName = nme.stripModuleSuffix(name).toTermName
-        val sym          = forceMangledName(strippedName.decodedName, true)
-        sym orElse definitions.getModule(strippedName)
-      }
-      else {
-        forceMangledName(name, false)
-        atPhase(currentRun.flattenPhase.next)(lookupClass(name))
-      }
-    )
-    if (sym.isModule) sym.moduleClass
-    else sym
+    val sym = if (name == fulltpnme.RuntimeNothing)
+      definitions.NothingClass
+    else if (name == fulltpnme.RuntimeNull)
+      definitions.NullClass
+    else if (nme.isImplClassName(name)) {
+      val iface = definitions.getClass(nme.interfaceName(name))
+      log("forcing " + iface.owner + " at phase: " + phase + " impl: " + iface.implClass)
+      iface.owner.info // force the mixin type-transformer
+      definitions.getClass(name)
+    }
+    else if (nme.isModuleName(name)) {
+      val strippedName = nme.stripModuleSuffix(name)
+      val sym = forceMangledName(newTermName(strippedName.decode), true)
+
+      if (sym == NoSymbol) definitions.getModule(strippedName)
+      else sym
+    }
+    else {
+      forceMangledName(name, false)
+      atPhase(currentRun.flattenPhase.next)(definitions.getClass(name))
+    }
+    if (sym.isModule)
+      sym.moduleClass
+    else
+      sym
   }
 
+
   var maxStack: Int = _
   var maxLocals: Int = _
   val JVM = ClassfileConstants // shorter, uppercase alias for use in case patterns