gistfile1.txt

scala> ListClass.info.members groupBy (_.associatedFile) foreach { case (k, vs) => println("%s\n  %s\n".format(k, vs map (_.defString) mkString "\n  ")) }

null
  final def asInstanceOf[T0]: T0
  final def isInstanceOf[T0]: Boolean
  final def !=(x$1: Any): Boolean
  final def ==(x$1: Any): Boolean

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/GenTraversableLike.class)
  final def isTraversableAgain: Boolean

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/GenSeqLike.class)
  override def equals(that: Any): Boolean
  def startsWith[B](that: scala.collection.GenSeq[B]): Boolean
  def lastIndexWhere(p: A => Boolean): Int
  def lastIndexOf[B >: A](elem: B,end: Int): Int
  def lastIndexOf[B >: A](elem: B): Int
  def indexOf[B >: A](elem: B,from: Int): Int
  def indexOf[B >: A](elem: B): Int
  def indexWhere(p: A => Boolean): Int
  def prefixLength(p: A => Boolean): Int

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/LinearSeqOptimized.class)
  private def scala$collection$LinearSeqOptimized$$super$sameElements[B >: A](that: scala.collection.GenIterable[B]): Boolean
  override def lastIndexWhere(p: A => Boolean,end: Int): Int
  override def indexWhere(p: A => Boolean,from: Int): Int
  override def segmentLength(p: A => Boolean,from: Int): Int
  override def isDefinedAt(x: Int): Boolean
  override def lengthCompare(len: Int): Int
  override def sameElements[B >: A](that: scala.collection.GenIterable[B]): Boolean
  override def dropRight(n: Int): Repr
  override def last: A
  override def reduceRight[B >: A](op: (A, B) => B): B
  override def reduceLeft[B >: A](f: (B, A) => B): B
  override def foldRight[B](z: B)(f: (A, B) => B): B
  override def foldLeft[B](z: B)(f: (B, A) => B): B
  override def find(p: A => Boolean): Option[A]
  override def count(p: A => Boolean): Int
  override def exists(p: A => Boolean): Boolean
  override def forall(p: A => Boolean): Boolean
  override def foreach[B](f: A => B): Unit
  def apply(n: Int): A
  def length: Int
  def $init$(): Unit

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/Parallelizable.class)
  def par: ParRepr

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/immutable/LinearSeq.class)
  override def seq: scala.collection.immutable.LinearSeq[A]

/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Classes/classes.jar(java/lang/Object.class)
  final def $asInstanceOf[T0](): T0
  final def $isInstanceOf[T0](): Boolean
  final def synchronized[T0](x$1: T0): T0
  final def ##(): Int
  final def !=(x$1: AnyRef): Boolean
  final def ==(x$1: AnyRef): Boolean
  final def ne(x$1: AnyRef): Boolean
  final def eq(x$1: AnyRef): Boolean
  protected[package lang] def finalize(): Unit
  final def wait(): Unit
  final def wait(x$1: Long,x$2: Int): Unit
  final def wait(x$1: Long): Unit
  final def notifyAll(): Unit
  final def notify(): Unit
  protected[package lang] def clone(): Object
  final def getClass(): Class[_]

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/LinearSeqLike.class)
  final override def corresponds[B](that: scala.collection.GenSeq[B])(p: (A, B) => Boolean): Boolean
  override def iterator: Iterator[A]
  override def hashCode(): Int
  override protected[this] def toCollection(repr: Repr): scala.collection.LinearSeq[A]
  override protected[this] def thisCollection: scala.collection.LinearSeq[A]

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/immutable/Seq.class)
  override protected[this] def parCombiner: scala.collection.parallel.Combiner[A,scala.collection.parallel.immutable.ParSeq[A]]
  override def toSeq: scala.collection.immutable.Seq[A]

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/generic/GenericTraversableTemplate.class)
  def transpose[B](implicit asTraversable: A => scala.collection.GenTraversableOnce[B]): CC[CC[B] @scala.annotation.unchecked.uncheckedVariance]
  def flatten[B](implicit asTraversable: A => scala.collection.GenTraversableOnce[B]): CC[B]
  def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])
  def unzip[A1, A2](implicit asPair: A => (A1, A2)): (CC[A1], CC[A2])
  private def sequential: scala.collection.TraversableOnce[A]
  def genericBuilder[B]: scala.collection.mutable.Builder[B,CC[B]]
  protected[this] def newBuilder: scala.collection.mutable.Builder[A,CC[A]]

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/TraversableOnce.class)
  def addString(b: StringBuilder): StringBuilder
  def addString(b: StringBuilder,sep: String): StringBuilder
  def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder
  def mkString: String
  def mkString(sep: String): String
  def mkString(start: String,sep: String,end: String): String
  def toMap[T, U](implicit ev: <:<[A,(T, U)]): scala.collection.immutable.Map[T,U]
  def toSet[B >: A]: scala.collection.immutable.Set[B]
  def toBuffer[B >: A]: scala.collection.mutable.Buffer[B]
  def toIndexedSeq: scala.collection.immutable.IndexedSeq[A]
  def toArray[B >: A](implicit evidence$1: ArrayTag[B]): Array[B]
  def copyToArray[B >: A](xs: Array[B]): Unit
  def copyToArray[B >: A](xs: Array[B],start: Int): Unit
  def copyToBuffer[B >: A](dest: scala.collection.mutable.Buffer[B]): Unit
  def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A
  def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A
  def max[B >: A](implicit cmp: Ordering[B]): A
  def min[B >: A](implicit cmp: Ordering[B]): A
  def product[B >: A](implicit num: Numeric[B]): B
  def sum[B >: A](implicit num: Numeric[B]): B
  def aggregate[B](z: B)(seqop: (B, A) => B,combop: (B, B) => B): B
  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  def reduceOption[A1 >: A](op: (A1, A1) => A1): Option[A1]
  def reduce[A1 >: A](op: (A1, A1) => A1): A1
  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
  def :\[B](z: B)(op: (A, B) => B): B
  def /:[B](z: B)(op: (B, A) => B): B
  def collectFirst[B](pf: PartialFunction[A,B]): Option[B]
  def nonEmpty: Boolean
  protected[this] def reversed: List[A]

/scala/trunk/build/pack/lib/scala-library.jar(scala/PartialFunction.class)
  def runWith[U](action: B => U): A => Boolean
  def run[U](x: A)(action: B => U): Boolean
  def applyOrElse[A1 <: A, B1 >: B](x: A1,default: A1 => B1): B1
  def lift: A => Option[B]
  override def andThen[C](k: B => C): PartialFunction[A,C]
  def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1,B1]): PartialFunction[A1,B1]

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/SeqLike.class)
  override def toString(): String
  override def view(from: Int,until: Int): scala.collection.SeqView[A,Repr]
  override def view: scala.collection.SeqView[A,Repr]
  def indices: scala.collection.immutable.Range
  def sorted[B >: A](implicit ord: scala.math.Ordering[B]): Repr
  def sortBy[B](f: A => B)(implicit ord: scala.math.Ordering[B]): Repr
  def sortWith(lt: (A, A) => Boolean): Repr
  def padTo[B >: A, That](len: Int,elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def :+[B >: A, That](elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def updated[B >: A, That](index: Int,elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def patch[B >: A, That](from: Int,patch: scala.collection.GenSeq[B],replaced: Int)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def distinct: Repr
  private def occCounts[B](sq: Seq[B]): scala.collection.mutable.Map[B,Int]
  def intersect[B >: A](that: scala.collection.GenSeq[B]): Repr
  def diff[B >: A](that: scala.collection.GenSeq[B]): Repr
  override def union[B >: A, That](that: scala.collection.GenSeq[B])(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def contains(elem: Any): Boolean
  def containsSlice[B](that: scala.collection.GenSeq[B]): Boolean
  def lastIndexOfSlice[B >: A](that: scala.collection.GenSeq[B],end: Int): Int
  def lastIndexOfSlice[B >: A](that: scala.collection.GenSeq[B]): Int
  def indexOfSlice[B >: A](that: scala.collection.GenSeq[B],from: Int): Int
  def indexOfSlice[B >: A](that: scala.collection.GenSeq[B]): Int
  def endsWith[B](that: scala.collection.GenSeq[B]): Boolean
  def startsWith[B](that: scala.collection.GenSeq[B],offset: Int): Boolean
  def reverseIterator: Iterator[A]
  def reverseMap[B, That](f: A => B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  private class CombinationsItr extends 
  private class PermutationsItr extends 
  def combinations(n: Int): Iterator[Repr]
  def permutations: Iterator[Repr]
  override def size: Int

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/TraversableLike.class)
  private def iterateUntilEmpty(f: Traversable[A @scala.annotation.unchecked.uncheckedVariance] => Traversable[A @scala.annotation.unchecked.uncheckedVariance]): Iterator[Repr]
  class WithFilter extends 
  def withFilter(p: A => Boolean): scala.collection.generic.FilterMonadic[A,Repr]
  def toTraversable: Traversable[A]
  def inits: Iterator[Repr]
  def tails: Iterator[Repr]
  private[package scala] def sliceWithKnownBound(from: Int,until: Int): Repr
  private[package scala] def sliceWithKnownDelta(from: Int,until: Int,delta: Int): Repr
  def init: Repr
  def lastOption: Option[A]
  override def tail: Repr
  def headOption: Option[A]
  def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def groupBy[K](f: A => K): scala.collection.immutable.Map[K,Repr]
  def partition(p: A => Boolean): (Repr, Repr)
  def collect[B, That](pf: PartialFunction[A,B])(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def filterNot(p: A => Boolean): Repr
  def filter(p: A => Boolean): Repr
  def flatMap[B, That](f: A => scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def map[B, That](f: A => B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def ++:[B >: A, That](that: Traversable[B])(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def ++:[B >: A, That](that: scala.collection.TraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[Repr,B,That]): That
  def hasDefiniteSize: Boolean
  def repr: Repr
  protected type Self = <?>

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/IterableLike.class)
  override def canEqual(that: Any): Boolean
  def zipWithIndex[A1 >: A, That](implicit bf: scala.collection.generic.CanBuildFrom[Repr,(A1, Int),That]): That
  def zipAll[B, A1 >: A, That](that: scala.collection.GenIterable[B],thisElem: A1,thatElem: B)(implicit bf: scala.collection.generic.CanBuildFrom[Repr,(A1, B),That]): That
  def zip[A1 >: A, B, That](that: scala.collection.GenIterable[B])(implicit bf: scala.collection.generic.CanBuildFrom[Repr,(A1, B),That]): That
  override def copyToArray[B >: A](xs: Array[B],start: Int,len: Int): Unit
  def sliding(size: Int,step: Int): Iterator[Repr]
  def sliding(size: Int): Iterator[Repr]
  def grouped(size: Int): Iterator[Repr]
  override def head: A
  override def toIterator: Iterator[A]
  override def toIterable: Iterable[A]
  override def isEmpty: Boolean

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/immutable/List.class)
  def removeDuplicates: List[A]
  override def toStream: scala.collection.immutable.Stream[A]
  override def stringPrefix: String
  override def reverse: List[A]
  override def span(p: A => Boolean): (List[A], List[A])
  override def dropWhile(p: A => Boolean): List[A]
  override def takeWhile(p: A => Boolean): List[A]
  override def splitAt(n: Int): (List[A], List[A])
  override def takeRight(n: Int): List[A]
  override def slice(from: Int,until: Int): List[A]
  override def drop(n: Int): List[A]
  override def take(n: Int): List[A]
  override def toList: List[A]
  override def +:[B >: A, That](elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[List[A],B,That]): That
  override def ++[B >: A, That](that: scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[List[A],B,That]): That
  def mapConserve[B >: A <: AnyRef](f: A => B): List[B]
  def reverse_:::[B >: A](prefix: List[B]): List[B]
  def :::[B >: A](prefix: List[B]): List[B]
  def ::[B >: A](x: B): List[B]
  override def companion: scala.collection.generic.GenericCompanion[List]
  def <init>(): List[A]

/scala/trunk/build/pack/lib/scala-library.jar(scala/Product.class)
  def productPrefix: String
  def productIterator: Iterator[Any]
  def productArity: Int
  def productElement(n: Int): Any

/scala/trunk/build/pack/lib/scala-library.jar(scala/Function1.class)
  def compose[A](g: A => T1): A => R

/scala/trunk/build/pack/lib/scala-library.jar(scala/collection/GenTraversableOnce.class)
  def /:\[A1 >: A](z: A1)(op: (A1, A1) => A1): A1