Eliminate breaking relative names in source.

These things are killing me.  Constructions like

  package scala.foo.bar.baz
  import foo.Other

DO NOT WORK in general.  Such files are not really in the
"scala" package, because it is not declared

  package scala
  package foo.bar.baz

And there is a second problem: using a relative path name means
compilation will fail in the presence of a directory of the same
name, e.g.

  % mkdir reflect
  % scalac src/reflect/scala/reflect/internal/util/Position.scala
  src/reflect/scala/reflect/internal/util/Position.scala:9: error:
    object ClassTag is not a member of package reflect
  import reflect.ClassTag
         ^
  src/reflect/scala/reflect/internal/util/Position.scala:10: error:
    object base is not a member of package reflect
  import reflect.base.Attachments
                 ^

As a rule, do not use relative package paths unless you have
explicitly imported the path to which you think you are relative.
Better yet, don't use them at all. Unfortunately they mostly work
because scala variously thinks everything scala.* is in the scala
package and/or because you usually aren't bootstrapping and it
falls through to an existing version of the class already on the
classpath.

Making the paths explicit is not a complete solution -
in particular, we remain enormously vulnerable to any directory
or package called "scala" which isn't ours - but it greatly
limts the severity of the problem.

1 files changed, 6 insertions, 6 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 08978ef4b5..e3f0756b6c 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -11,13 +11,13 @@
 package scala.tools.nsc
 package typechecker
 
-import annotation.tailrec
+import scala.annotation.tailrec
 import scala.collection.{ mutable, immutable }
 import mutable.{ LinkedHashMap, ListBuffer }
 import scala.util.matching.Regex
 import symtab.Flags._
 import scala.reflect.internal.util.Statistics
-import language.implicitConversions
+import scala.language.implicitConversions
 
 /** This trait provides methods to find various kinds of implicits.
  *
@@ -1217,14 +1217,14 @@ trait Implicits {
     private val ManifestSymbols = Set[Symbol](PartialManifestClass, FullManifestClass, OptManifestClass)
 
     /** Creates a tree that calls the relevant factory method in object
-      * reflect.Manifest for type 'tp'. An EmptyTree is returned if
+      * scala.reflect.Manifest for type 'tp'. An EmptyTree is returned if
       * no manifest is found. todo: make this instantiate take type params as well?
       */
     private def manifestOfType(tp: Type, flavor: Symbol): SearchResult = {
       val full = flavor == FullManifestClass
       val opt = flavor == OptManifestClass
 
-      /** Creates a tree that calls the factory method called constructor in object reflect.Manifest */
+      /** Creates a tree that calls the factory method called constructor in object scala.reflect.Manifest */
       def manifestFactoryCall(constructor: String, tparg: Type, args: Tree*): Tree =
         if (args contains EmptyTree) EmptyTree
         else typedPos(tree.pos.focus) {
@@ -1472,7 +1472,7 @@ trait Implicits {
         interpolate(msg, Map((typeParamNames zip typeArgs): _*)) // TODO: give access to the name and type of the implicit argument, etc?
 
       def validate: Option[String] = {
-        import scala.util.matching.Regex; import collection.breakOut
+        import scala.util.matching.Regex; import scala.collection.breakOut
         // is there a shorter way to avoid the intermediate toList?
         val refs = """\$\{([^}]+)\}""".r.findAllIn(msg).matchData.map(_ group 1).toSet
         val decls = typeParamNames.toSet
@@ -1492,7 +1492,7 @@ trait Implicits {
 
 object ImplicitsStats {
 
-  import reflect.internal.TypesStats._
+  import scala.reflect.internal.TypesStats._
 
   val rawTypeImpl         = Statistics.newSubCounter ("  of which in implicits", rawTypeCount)
   val subtypeImpl         = Statistics.newSubCounter("  of which in implicit", subtypeCount)