2 files changed, 51 insertions, 1 deletions
diff --git a/src/library/scala/reflect/base/Base.scala b/src/library/scala/reflect/base/Base.scala
index a4e6256f4d..4457a6cf14 100644
--- a/src/library/scala/reflect/base/Base.scala
+++ b/src/library/scala/reflect/base/Base.scala
@@ -357,6 +357,9 @@ class Base extends Universe { self =>
     def staticModule(fullName: String): ModuleSymbol =
       mkStatic[ModuleSymbol](fullName)
 
+    def staticPackage(fullName: String): ModuleSymbol =
+      staticModule(fullName) // this toy universe doesn't care about the distinction between packages and modules
+
     private def mkStatic[S <: Symbol : ClassTag](fullName: String): S =
       cached(fullName) {
         val point = fullName lastIndexOf '.'
diff --git a/src/library/scala/reflect/base/MirrorOf.scala b/src/library/scala/reflect/base/MirrorOf.scala
index d030ace96c..6dc8090eee 100644
--- a/src/library/scala/reflect/base/MirrorOf.scala
+++ b/src/library/scala/reflect/base/MirrorOf.scala
@@ -25,7 +25,7 @@ abstract class MirrorOf[U <: base.Universe with Singleton] {
    *    scala> res0.fullName
    *    res1: String = scala.collection.immutable.List
    *
-   *    scala> cm.staticModule("scala")
+   *    scala> cm.staticPackage("scala")
    *    res2: reflect.runtime.universe.ModuleSymbol = package scala
    *
    *    scala> res2.moduleClass.typeSignature member newTypeName("List")
@@ -33,11 +33,58 @@ abstract class MirrorOf[U <: base.Universe with Singleton] {
    *
    *    scala> res3.fullName
    *    res4: String = scala.List
+   *
+   *  To be consistent with Scala name resolution rules, in case of ambiguity between
+   *  a package and an object, the object is never been considered.
+   *
+   *  For example for the following code:
+   *
+   *    package foo {
+   *      class B
+   *    }
+   *
+   *    object foo {
+   *      class A
+   *      class B
+   *    }
+   *
+   *  staticClass("foo.B") will resolve to the symbol corresponding to the class B declared in the package foo, and
+   *  staticClass("foo.A") will throw a MissingRequirementException (which is exactly what scalac would do if this
+   *  fully qualified class name is written inside any package in a Scala program).
+   *
+   *  In the example above, to load a symbol that corresponds to the class B declared in the object foo,
+   *  use staticModule("foo") to load the module symbol and then navigate typeSignature.members of its moduleClass.
    */
   def staticClass(fullName: String): U#ClassSymbol
 
   /** The symbol corresponding to the globally accessible object with the
    *  given fully qualified name `fullName`.
+   *
+   *  To be consistent with Scala name resolution rules, in case of ambiguity between
+   *  a package and an object, the object is never been considered.
+   *
+   *  For example for the following code:
+   *
+   *    package foo {
+   *      object B
+   *    }
+   *
+   *    object foo {
+   *      object A
+   *      object B
+   *    }
+   *
+   *  staticModule("foo.B") will resolve to the symbol corresponding to the object B declared in the package foo, and
+   *  staticModule("foo.A") will throw a MissingRequirementException (which is exactly what scalac would do if this
+   *  fully qualified class name is written inside any package in a Scala program).
+   *
+   *  In the example above, to load a symbol that corresponds to the object B declared in the object foo,
+   *  use staticModule("foo") to load the module symbol and then navigate typeSignature.members of its moduleClass.
    */
   def staticModule(fullName: String): U#ModuleSymbol
+
+  /** The symbol corresponding to a package with the
+   *  given fully qualified name `fullName`.
+   */
+  def staticPackage(fullName: String): U#ModuleSymbol
 }