Minor tweaks in Types/Scopes.

All methods to do with handling imports more uniformly and early
filtering of symbols which cannot be imported. Also make TypeBounds
treat a Wildcard in lower or upper bounds as an empty bound, so we
don't see all these method signatures like

  def f[T >: ? <: ?]

because that's not helpful.

Author: paulp

src/compiler/scala/tools/nsc/typechecker/Contexts.scala

@@ -1006,7 +1006,7 @@ trait Contexts { self: Analyzer =>
     }
 
     def allImportedSymbols: Iterable[Symbol] =
-      qual.tpe.members flatMap (transformImport(tree.selectors, _))
+      importableMembers(qual.tpe) flatMap (transformImport(tree.selectors, _))
 
     private def transformImport(selectors: List[ImportSelector], sym: Symbol): List[Symbol] = selectors match {
       case List() => List()

src/reflect/scala/reflect/internal/Definitions.scala

@@ -235,6 +235,26 @@ trait Definitions extends api.StandardDefinitions {
       scope.sorted foreach fullyInitializeSymbol
       scope
     }
+    /** Is this symbol a member of Object or Any? */
+    def isUniversalMember(sym: Symbol) = (
+         (sym ne NoSymbol)
+      && (ObjectClass isSubClass sym.owner)
+    )
+
+    /** Is this symbol unimportable? Unimportable symbols include:
+     *  - constructors, because <init> is not a real name
+     *  - private[this] members, which cannot be referenced from anywhere else
+     *  - members of Any or Object, because every instance will inherit a
+     *    definition which supersedes the imported one
+     */
+    def isUnimportable(sym: Symbol) = (
+         (sym eq NoSymbol)
+      || sym.isConstructor
+      || sym.isPrivateLocal
+      || isUniversalMember(sym)
+    )
+    def isImportable(sym: Symbol) = !isUnimportable(sym)
+
     /** Is this type equivalent to Any, AnyVal, or AnyRef? */
     def isTrivialTopType(tp: Type) = (
          tp =:= AnyClass.tpe

src/reflect/scala/reflect/internal/Scopes.scala

@@ -341,36 +341,19 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
      */
     def iterator: Iterator[Symbol] = toList.iterator
 
-/*
-    /** Does this scope contain an entry for `sym`?
-     */
-    def contains(sym: Symbol): Boolean = lookupAll(sym.name) contains sym
-
-    /** A scope that contains all symbols of this scope and that also contains `sym`.
-     */
-    def +(sym: Symbol): Scope =
-      if (contains(sym)) this
-      else {
-        val result = cloneScope
-        result enter sym
-        result
-      }
+    def containsName(name: Name) = lookupEntry(name) != null
+    def containsSymbol(s: Symbol) = lookupAll(s.name) contains s
 
-    /** A scope that contains all symbols of this scope except `sym`.
-     */
-    def -(sym: Symbol): Scope =
-      if (!contains(sym)) this
-      else {
-        val result = cloneScope
-        result unlink sym
-        result
-      }
-*/
     override def foreach[U](p: Symbol => U): Unit = toList foreach p
 
-    override def filter(p: Symbol => Boolean): Scope =
-      if (!(toList forall p)) newScopeWith(toList filter p: _*) else this
-
+    override def filterNot(p: Symbol => Boolean): Scope = (
+      if (toList exists p) newScopeWith(toList filterNot p: _*)
+      else this
+    )
+    override def filter(p: Symbol => Boolean): Scope = (
+      if (toList forall p) this
+      else newScopeWith(toList filter p: _*)
+    )
     @deprecated("Use `toList.reverse` instead", "2.10.0")
     def reverse: List[Symbol] = toList.reverse
 

src/reflect/scala/reflect/internal/Types.scala

@@ -1516,8 +1516,8 @@ trait Types extends api.Types { self: SymbolTable =>
     }
     private def lowerString = if (emptyLowerBound) "" else " >: " + lo
     private def upperString = if (emptyUpperBound) "" else " <: " + hi
-    private def emptyLowerBound = typeIsNothing(lo)
-    private def emptyUpperBound = typeIsAny(hi)
+    private def emptyLowerBound = typeIsNothing(lo) || lo.isWildcard
+    private def emptyUpperBound = typeIsAny(hi) || hi.isWildcard
     def isEmptyBounds = emptyLowerBound && emptyUpperBound
 
     // override def isNullable: Boolean = NullClass.tpe <:< lo;
@@ -7240,8 +7240,12 @@ trait Types extends api.Types { self: SymbolTable =>
   /** Members of the given class, other than those inherited
    *  from Any or AnyRef.
    */
-  def nonTrivialMembers(clazz: Symbol): Iterable[Symbol] =
-    clazz.info.members filterNot (sym => sym.owner == ObjectClass || sym.owner == AnyClass)
+  def nonTrivialMembers(clazz: Symbol): Scope = clazz.info.members filterNot isUniversalMember
+
+  /** Members which can be imported into other scopes.
+   */
+  def importableMembers(clazz: Symbol): Scope = importableMembers(clazz.info)
+  def importableMembers(pre: Type): Scope     = pre.members filter isImportable
 
   def objToAny(tp: Type): Type =
     if (!phase.erasedTypes && tp.typeSymbol == ObjectClass) AnyClass.tpe