Merge 2.10.x into master.

Resurrect some undead code from 373ded2ad3 (tuple2Pickler).

Conflicts:
	src/compiler/scala/tools/nsc/interactive/CompilerControl.scala
	src/compiler/scala/tools/nsc/typechecker/Typers.scala

15 files changed, 237 insertions, 191 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala
index eac43c146a..3397797927 100755
--- a/src/compiler/scala/tools/nsc/ast/DocComments.scala
+++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala
@@ -53,6 +53,11 @@ trait DocComments { self: Global =>
     else sym.owner.ancestors map (sym overriddenSymbol _) filter (_ != NoSymbol)
   }
 
+  def fillDocComment(sym: Symbol, comment: DocComment) {
+    docComments(sym) = comment
+    comment.defineVariables(sym)
+  }
+
   /** The raw doc comment of symbol `sym`, minus usecase and define sections, augmented by
    *  missing sections of an inherited doc comment.
    *  If a symbol does not have a doc comment but some overridden version of it does,
diff --git a/src/compiler/scala/tools/nsc/doc/ScaladocGlobal.scala b/src/compiler/scala/tools/nsc/doc/ScaladocGlobal.scala
index b8a0637b47..021e59a879 100644
--- a/src/compiler/scala/tools/nsc/doc/ScaladocGlobal.scala
+++ b/src/compiler/scala/tools/nsc/doc/ScaladocGlobal.scala
@@ -25,8 +25,7 @@ trait ScaladocAnalyzer extends Analyzer {
 
       if ((sym ne null) && (sym ne NoSymbol)) {
         val comment = docDef.comment
-        docComments(sym) = comment
-        comment.defineVariables(sym)
+        fillDocComment(sym, comment)
         val typer1 = newTyper(context.makeNewScope(docDef, context.owner))
         for (useCase <- comment.useCases) {
           typer1.silent(_ => typer1 defineUseCases useCase) match {
diff --git a/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala b/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala
index a81604235b..523e0d57b7 100644
--- a/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala
+++ b/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala
@@ -161,17 +161,22 @@ trait CompilerControl { self: Global =>
 
   /** Sets sync var `response` to doc comment information for a given symbol.
    *
-   *  @param   sym      The symbol whose doc comment should be retrieved (might come from a classfile)
-   *  @param   site     The place where sym is observed.
-   *  @param   source   The source file that's supposed to contain the definition
-   *  @param   response A response that will be set to the following:
-   *                    If `source` contains a definition of a given symbol that has a doc comment,
-   *                    the (expanded, raw, position) triplet for a comment, otherwise ("", "", NoPosition).
-   *  Note: This operation does not automatically load `source`. If `source`
-   *  is unloaded, it stays that way.
+   *  @param   sym        The symbol whose doc comment should be retrieved (might come from a classfile)
+   *  @param   source     The source file that's supposed to contain the definition
+   *  @param   site       The symbol where 'sym' is observed
+   *  @param   fragments  All symbols that can contribute to the generated documentation
+   *                      together with their source files.
+   *  @param   response   A response that will be set to the following:
+   *                      If `source` contains a definition of a given symbol that has a doc comment,
+   *                      the (expanded, raw, position) triplet for a comment, otherwise ("", "", NoPosition).
+   *  Note: This operation does not automatically load sources that are not yet loaded.
    */
-  def askDocComment(sym: Symbol, site: Symbol, source: SourceFile, response: Response[(String, String, Position)]) =
-    postWorkItem(new AskDocCommentItem(sym, site, source, response))
+  def askDocComment(sym: Symbol, source: SourceFile, site: Symbol, fragments: List[(Symbol,SourceFile)], response: Response[(String, String, Position)]): Unit =
+    postWorkItem(new AskDocCommentItem(sym, source, site, fragments, response))
+
+  @deprecated("Use method that accepts fragments", "2.10.2")
+  def askDocComment(sym: Symbol, site: Symbol, source: SourceFile, response: Response[(String, String, Position)]): Unit =
+    askDocComment(sym, source, site, (sym,source)::Nil, response)
 
   /** Sets sync var `response` to list of members that are visible
    *  as members of the tree enclosing `pos`, possibly reachable by an implicit.
@@ -384,9 +389,9 @@ trait CompilerControl { self: Global =>
       response raise new MissingResponse
   }
 
-  case class AskDocCommentItem(sym: Symbol, site: Symbol, source: SourceFile, response: Response[(String, String, Position)]) extends WorkItem {
-    def apply() = self.getDocComment(sym, site, source, response)
-    override def toString = "doc comment "+sym+" in "+source
+  case class AskDocCommentItem(sym: Symbol, source: SourceFile, site: Symbol, fragments: List[(Symbol,SourceFile)], response: Response[(String, String, Position)]) extends WorkItem {
+    def apply() = self.getDocComment(sym, source, site, fragments, response)
+    override def toString = "doc comment "+sym+" in "+source+" with fragments:"+fragments.mkString("(", ",", ")")
 
     def raiseMissing() =
       response raise new MissingResponse
diff --git a/src/compiler/scala/tools/nsc/interactive/Global.scala b/src/compiler/scala/tools/nsc/interactive/Global.scala
index 921a07c805..33b10d1a9a 100644
--- a/src/compiler/scala/tools/nsc/interactive/Global.scala
+++ b/src/compiler/scala/tools/nsc/interactive/Global.scala
@@ -665,8 +665,8 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
    *  If we do just removeUnit, some problems with default parameters can ensue.
    *  Calls to this method could probably be replaced by removeUnit once default parameters are handled more robustly.
    */
-  private def afterRunRemoveUnitOf(source: SourceFile) {
-    toBeRemovedAfterRun += source.file
+  private def afterRunRemoveUnitsOf(sources: List[SourceFile]) {
+    toBeRemovedAfterRun ++= sources map (_.file)
   }
 
   /** A fully attributed tree located at position `pos` */
@@ -674,7 +674,7 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
     case None =>
       reloadSources(List(pos.source))
       try typedTreeAt(pos)
-      finally afterRunRemoveUnitOf(pos.source)
+      finally afterRunRemoveUnitsOf(List(pos.source))
     case Some(unit) =>
       informIDE("typedTreeAt " + pos)
       parseAndEnter(unit)
@@ -724,14 +724,23 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
     respond(response)(typedTree(source, forceReload))
   }
 
+  private def withTempUnits[T](sources: List[SourceFile])(f: (SourceFile => RichCompilationUnit) => T): T = {
+    val unitOfSrc: SourceFile => RichCompilationUnit = src => unitOfFile(src.file)
+    sources filterNot (getUnit(_).isDefined) match {
+      case Nil =>
+        f(unitOfSrc)
+      case unknown =>
+        reloadSources(unknown)
+        try {
+          f(unitOfSrc)
+        } finally
+          afterRunRemoveUnitsOf(unknown)
+    }
+  }
+
   private def withTempUnit[T](source: SourceFile)(f: RichCompilationUnit => T): T =
-    getUnit(source) match {
-      case None =>
-        reloadSources(List(source))
-        try f(getUnit(source).get)
-        finally afterRunRemoveUnitOf(source)
-      case Some(unit) =>
-        f(unit)
+    withTempUnits(List(source)){ srcToUnit =>
+      f(srcToUnit(source))
     }
 
   /** Find a 'mirror' of symbol `sym` in unit `unit`. Pre: `unit is loaded. */
@@ -795,50 +804,36 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
     }
   }
 
+  private def forceDocComment(sym: Symbol, unit: RichCompilationUnit) {
+    unit.body foreachPartial {
+      case DocDef(comment, defn) if defn.symbol == sym =>
+        fillDocComment(defn.symbol, comment)
+        EmptyTree
+      case _: ValOrDefDef =>
+        EmptyTree
+    }
+  }
+
   /** Implements CompilerControl.askDocComment */
-  private[interactive] def getDocComment(sym: Symbol, site: Symbol, source: SourceFile, response: Response[(String, String, Position)]) {
-    informIDE("getDocComment "+sym+" "+source)
+  private[interactive] def getDocComment(sym: Symbol, source: SourceFile, site: Symbol, fragments: List[(Symbol,SourceFile)],
+                                         response: Response[(String, String, Position)]) {
+    informIDE(s"getDocComment $sym at $source site $site")
     respond(response) {
-      withTempUnit(source){ u =>
-        val mirror = findMirrorSymbol(sym, u)
+      withTempUnits(fragments.toList.unzip._2){ units =>
+        for((sym, src) <- fragments) {
+          val mirror = findMirrorSymbol(sym, units(src))
+          if (mirror ne NoSymbol) forceDocComment(mirror, units(src))
+        }
+        val mirror = findMirrorSymbol(sym, units(source))
         if (mirror eq NoSymbol)
           ("", "", NoPosition)
         else {
-          forceDocComment(mirror, u)
-          (expandedDocComment(mirror), rawDocComment(mirror), docCommentPos(mirror))
+          (expandedDocComment(mirror, site), rawDocComment(mirror), docCommentPos(mirror))
         }
       }
     }
   }
 
-  private def forceDocComment(sym: Symbol, unit: RichCompilationUnit) {
-    // Either typer has been run and we don't find DocDef,
-    // or we force the targeted typecheck here.
-    // In both cases doc comment maps should be filled for the subject symbol.
-    val docTree =
-      unit.body find {
-        case DocDef(_, defn) if defn.symbol eq sym => true
-        case _ => false
-      }
-
-    for (t <- docTree) {
-      debugLog("Found DocDef tree for "+sym)
-      // Cannot get a typed tree at position since DocDef range is transparent.
-      val prevPos = unit.targetPos
-      val prevInterruptsEnabled = interruptsEnabled
-      try {
-        unit.targetPos = t.pos
-        interruptsEnabled = true
-        typeCheck(unit)
-      } catch {
-        case _: TyperResult => // ignore since we are after the side effect.
-      } finally {
-        unit.targetPos = prevPos
-        interruptsEnabled = prevInterruptsEnabled
-      }
-    }
-  }
-
   def stabilizedType(tree: Tree): Type = tree match {
     case Ident(_) if tree.symbol.isStable =>
       singleType(NoPrefix, tree.symbol)
diff --git a/src/compiler/scala/tools/nsc/interactive/Picklers.scala b/src/compiler/scala/tools/nsc/interactive/Picklers.scala
index 09533fdeb5..b184afd0f5 100644
--- a/src/compiler/scala/tools/nsc/interactive/Picklers.scala
+++ b/src/compiler/scala/tools/nsc/interactive/Picklers.scala
@@ -164,8 +164,8 @@ trait Picklers { self: Global =>
       .asClass (classOf[AskLinkPosItem])
 
   implicit def askDocCommentItem: CondPickler[AskDocCommentItem] =
-    (pkl[Symbol] ~ pkl[Symbol] ~ pkl[SourceFile])
-      .wrapped { case sym ~ site ~ source => new AskDocCommentItem(sym, site, source, new Response) } { item => item.sym ~ item.site ~ item.source }
+    (pkl[Symbol] ~ pkl[SourceFile] ~ pkl[Symbol] ~ pkl[List[(Symbol,SourceFile)]])
+      .wrapped { case sym ~ source ~ site ~ fragments => new AskDocCommentItem(sym, source, site, fragments, new Response) } { item => item.sym ~ item.source ~ item.site ~ item.fragments }
       .asClass (classOf[AskDocCommentItem])
 
   implicit def askLoadedTypedItem: CondPickler[AskLoadedTypedItem] =
diff --git a/src/compiler/scala/tools/nsc/io/Pickler.scala b/src/compiler/scala/tools/nsc/io/Pickler.scala
index 43a6ef3c61..0e7da37c52 100644
--- a/src/compiler/scala/tools/nsc/io/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/io/Pickler.scala
@@ -327,6 +327,12 @@ object Pickler {
     }
   }
 
+  /** A pickler for pairs, represented as `~`-pairs */
+  implicit def tuple2Pickler[T1: Pickler, T2: Pickler]: Pickler[(T1, T2)] =
+    (pkl[T1] ~ pkl[T2])
+      .wrapped { case x1 ~ x2 => (x1, x2) } { case (x1, x2) => x1 ~ x2 }
+      .labelled ("tuple2")
+
   /** A pickler for 3-tuples, represented as `~`-tuples */
   implicit def tuple3Pickler[T1, T2, T3](implicit p1: Pickler[T1], p2: Pickler[T2], p3: Pickler[T3]): Pickler[(T1, T2, T3)] =
     (p1 ~ p2 ~ p3)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 5785fa620b..959c5a0eb8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1022,7 +1022,7 @@ trait Typers extends Adaptations with Tags {
             val pre =
               if (owner.isPackageClass) owner.thisType
               else if (owner.isClass) context.enclosingSubClassContext(owner).prefix
-            else NoPrefix
+              else NoPrefix
             stabilize0(pre)
           case Select(qualqual, _) =>
             stabilize0(qualqual.tpe)
@@ -1577,19 +1577,19 @@ trait Typers extends Adaptations with Tags {
      *  from one of the parent types. Read more about why the argss are unknown in `tools.nsc.ast.Trees.Template`.
      */
     private def typedPrimaryConstrBody(templ: Template)(actualSuperCall: => Tree): Tree =
-      treeInfo.firstConstructor(templ.body) match {
+        treeInfo.firstConstructor(templ.body) match {
         case ctor @ DefDef(_, _, _, vparamss, _, cbody @ Block(cstats, cunit)) =>
-          val (preSuperStats, superCall) = {
-            val (stats, rest) = cstats span (x => !treeInfo.isSuperConstrCall(x))
-            (stats map (_.duplicate), if (rest.isEmpty) EmptyTree else rest.head.duplicate)
-          }
+            val (preSuperStats, superCall) = {
+              val (stats, rest) = cstats span (x => !treeInfo.isSuperConstrCall(x))
+              (stats map (_.duplicate), if (rest.isEmpty) EmptyTree else rest.head.duplicate)
+            }
           val superCall1 = (superCall match {
             case global.pendingSuperCall => actualSuperCall
             case EmptyTree => EmptyTree
           }) orElse cunit
           val cbody1 = treeCopy.Block(cbody, preSuperStats, superCall1)
           val clazz = context.owner
-          assert(clazz != NoSymbol, templ)
+            assert(clazz != NoSymbol, templ)
           val cscope = context.outer.makeNewScope(ctor, context.outer.owner)
           val cbody2 = { // called both during completion AND typing.
             val typer1 = newTyper(cscope)
@@ -1597,12 +1597,12 @@ trait Typers extends Adaptations with Tags {
             clazz.unsafeTypeParams foreach (sym => typer1.context.scope.enter(sym))
             typer1.namer.enterValueParams(vparamss map (_.map(_.duplicate)))
             typer1.typed(cbody1)
-          }
+            }
 
-          val preSuperVals = treeInfo.preSuperFields(templ.body)
-          if (preSuperVals.isEmpty && preSuperStats.nonEmpty)
+            val preSuperVals = treeInfo.preSuperFields(templ.body)
+            if (preSuperVals.isEmpty && preSuperStats.nonEmpty)
             devWarning("Wanted to zip empty presuper val list with " + preSuperStats)
-          else
+            else
             map2(preSuperStats, preSuperVals)((ldef, gdef) => gdef.tpt setType ldef.symbol.tpe)
 
           if (superCall1 == cunit) EmptyTree
@@ -1610,13 +1610,13 @@ trait Typers extends Adaptations with Tags {
             case Block(_, expr) => expr
             case tree => tree
           }
-        case _ =>
+          case _ =>
           EmptyTree
-      }
+        }
 
     /** Makes sure that the first type tree in the list of parent types is always a class.
      *  If the first parent is a trait, prepend its supertype to the list until it's a class.
-     */
+*/
     private def normalizeFirstParent(parents: List[Tree]): List[Tree] = parents match {
       case first :: rest if treeInfo.isTraitRef(first) =>
         def explode(supertpt: Tree, acc: List[Tree]): List[Tree] = {
@@ -1643,14 +1643,14 @@ trait Typers extends Adaptations with Tags {
      *  So we strip the duplicates before typer.
      */
     private def fixDuplicateSyntheticParents(parents: List[Tree]): List[Tree] = parents match {
-      case Nil      => Nil
-      case x :: xs  =>
-        val sym = x.symbol
+          case Nil      => Nil
+          case x :: xs  =>
+            val sym = x.symbol
         x :: fixDuplicateSyntheticParents(
-          if (isPossibleSyntheticParent(sym)) xs filterNot (_.symbol == sym)
-          else xs
-        )
-    }
+              if (isPossibleSyntheticParent(sym)) xs filterNot (_.symbol == sym)
+              else xs
+            )
+        }
 
     def typedParentTypes(templ: Template): List[Tree] = templ.parents match {
       case Nil => List(atPos(templ.pos)(TypeTree(AnyRefClass.tpe)))
@@ -1671,16 +1671,16 @@ trait Typers extends Adaptations with Tags {
 
           supertpts mapConserve (tpt => checkNoEscaping.privates(context.owner, tpt))
         } catch {
-          case ex: TypeError =>
-            // fallback in case of cyclic errors
-            // @H none of the tests enter here but I couldn't rule it out
+        case ex: TypeError =>
+          // fallback in case of cyclic errors
+          // @H none of the tests enter here but I couldn't rule it out
             // upd. @E when a definition inherits itself, we end up here
             // because `typedParentType` triggers `initialize` for parent types symbols
-            log("Type error calculating parents in template " + templ)
-            log("Error: " + ex)
-            ParentTypesError(templ, ex)
-            List(TypeTree(AnyRefClass.tpe))
-        }
+          log("Type error calculating parents in template " + templ)
+          log("Error: " + ex)
+          ParentTypesError(templ, ex)
+          List(TypeTree(AnyRefClass.tpe))
+      }
     }
 
     /** <p>Check that</p>
@@ -1926,7 +1926,7 @@ trait Typers extends Adaptations with Tags {
       assert(clazz.info.decls != EmptyScope, clazz)
       enterSyms(context.outer.make(templ, clazz, clazz.info.decls), templ.body)
       if (!templ.isErrorTyped) // if `parentTypes` has invalidated the template, don't validate it anymore
-        validateParentClasses(parents1, selfType)
+      validateParentClasses(parents1, selfType)
       if (clazz.isCase)
         validateNoCaseAncestor(clazz)
       if (clazz.isTrait && hasSuperArgs(parents1.head))
@@ -1939,9 +1939,9 @@ trait Typers extends Adaptations with Tags {
         checkFinitary(clazz.info.resultType.asInstanceOf[ClassInfoType])
 
       val body = {
-        val body =
-          if (isPastTyper || reporter.hasErrors) templ.body
-          else templ.body flatMap rewrappingWrapperTrees(namer.addDerivedTrees(Typer.this, _))
+      val body =
+        if (isPastTyper || reporter.hasErrors) templ.body
+        else templ.body flatMap rewrappingWrapperTrees(namer.addDerivedTrees(Typer.this, _))
         val primaryCtor = treeInfo.firstConstructor(body)
         val primaryCtor1 = primaryCtor match {
           case DefDef(_, _, _, _, _, Block(earlyVals :+ global.pendingSuperCall, unit)) =>
@@ -2004,7 +2004,7 @@ trait Typers extends Adaptations with Tags {
       checkNonCyclic(vdef, tpt1)
 
       if (sym.hasAnnotation(definitions.VolatileAttr) && !sym.isMutable)
-          VolatileValueError(vdef)
+        VolatileValueError(vdef)
 
       val rhs1 =
         if (vdef.rhs.isEmpty) {
@@ -2166,7 +2166,7 @@ trait Typers extends Adaptations with Tags {
 
       foreachWithIndex(paramssTypes(meth.tpe)) { (paramList, listIdx) =>
         foreachWithIndex(paramList) { (paramType, paramIdx) =>
-        val sym = paramType.typeSymbol
+          val sym = paramType.typeSymbol
           def paramPos = nthParamPos(listIdx, paramIdx)
 
           /** Not enough to look for abstract types; have to recursively check the bounds
@@ -2181,17 +2181,17 @@ trait Typers extends Adaptations with Tags {
                 || (!sym.hasTransOwner(meth) && failStruct(paramPos, "a type member of that refinement", what))
                 || checkAbstract(sym.info.bounds.hi, "Type bound")
               )
-        }
+            }
             tp0.dealiasWidenChain forall (t => check(t.typeSymbol))
           }
           checkAbstract(paramType, "Parameter type")
 
-        if (sym.isDerivedValueClass)
-          failStruct(paramPos, "a user-defined value class")
-        if (paramType.isInstanceOf[ThisType] && sym == meth.owner)
-          failStruct(paramPos, "the type of that refinement (self type)")
+          if (sym.isDerivedValueClass)
+            failStruct(paramPos, "a user-defined value class")
+          if (paramType.isInstanceOf[ThisType] && sym == meth.owner)
+            failStruct(paramPos, "the type of that refinement (self type)")
+        }
       }
-    }
       if (resultType.typeSymbol.isDerivedValueClass)
         failStruct(ddef.tpt.pos, "a user-defined value class", where = "Result type")
     }
@@ -3447,7 +3447,7 @@ trait Typers extends Adaptations with Tags {
           else None
 
         case _ => None
-      }
+    }
     }
 
     /**
@@ -3635,7 +3635,7 @@ trait Typers extends Adaptations with Tags {
             val Function(arg :: Nil, rhs) = typed(func, mode, funcType)
 
             rhs.substituteSymbols(arg.symbol :: Nil, selfsym :: Nil)
-          }
+            }
 
           def annInfo(t: Tree): AnnotationInfo = t match {
             case Apply(Select(New(tpt), nme.CONSTRUCTOR), args) =>
@@ -3663,7 +3663,7 @@ trait Typers extends Adaptations with Tags {
           if ((typedAnn.tpe == null) || typedAnn.tpe.isErroneous) ErroneousAnnotation
           else annInfo(typedAnn)
       })
-    }
+        }
 
     def isRawParameter(sym: Symbol) = // is it a type parameter leaked by a raw type?
       sym.isTypeParameter && sym.owner.isJavaDefined
@@ -5013,8 +5013,8 @@ trait Typers extends Adaptations with Tags {
           def unbound(t: Tree) = t.symbol == null || t.symbol == NoSymbol
           cdef.pat match {
             case Bind(name, i @ Ident(_)) if unbound(i) => warn(name)
-            case i @ Ident(name) if unbound(i)          => warn(name)
-            case _                                      =>
+            case i @ Ident(name) if unbound(i) => warn(name)
+            case _ =>
           }
         }
 
diff --git a/test/files/pos/t7183.flags b/test/files/pos/t7183.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/pos/t7183.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/t7183.scala b/test/files/pos/t7183.scala
new file mode 100644
index 0000000000..7647c1634b
--- /dev/null
+++ b/test/files/pos/t7183.scala
@@ -0,0 +1,13 @@
+class A
+object A {
+  def unapply(a: A): Some[A] = Some(a) // Change return type to Option[A] and the warning is gone
+}
+
+object Test {
+  for (A(a) <- List(new A)) yield a // spurious dead code warning.
+}
+
+// List(new A()).withFilter(((check$ifrefutable$2) => check$ifrefutable$2: @scala.unchecked match {
+//  case A((a @ _)) => true
+//  case _ => false // this is dead code, but it's compiler generated.
+// }))
diff --git a/test/files/presentation/doc.check b/test/files/presentation/doc.check
index e33756773d..5a3ff13151 100644
--- a/test/files/presentation/doc.check
+++ b/test/files/presentation/doc.check
@@ -1,49 +1 @@
-reload: Test.scala
-body:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This is a test comment), Text(.)))), Text(
-))))))
-@example:Body(List(Paragraph(Chain(List(Summary(Monospace(Text("abb".permutations = Iterator(abb, bab, bba)))))))))
-@version:
-@since:
-@todo:
-@note:
-@see:
-body:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This is a test comment), Text(.)))), Text(
-))))))
-@example:Body(List(Paragraph(Chain(List(Summary(Monospace(Text("abb".permutations = Iterator(abb, bab, bba)))))))))
-@version:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(1), Text(.)))), Text(0, 09/07/2012))))))
-@since:
-@todo:
-@note:
-@see:
-body:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This is a test comment), Text(.)))), Text(
-))))))
-@example:Body(List(Paragraph(Chain(List(Summary(Monospace(Text("abb".permutations = Iterator(abb, bab, bba)))))))))
-@version:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(1), Text(.)))), Text(0, 09/07/2012))))))
-@since:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(2), Text(.)))), Text(10))))))
-@todo:
-@note:
-@see:
-body:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This is a test comment), Text(.)))), Text(
-))))))
-@example:Body(List(Paragraph(Chain(List(Summary(Monospace(Text("abb".permutations = Iterator(abb, bab, bba)))))))))
-@version:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(1), Text(.)))), Text(0, 09/07/2012))))))
-@since:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(2), Text(.)))), Text(10))))))
-@todo:Body(List(Paragraph(Chain(List(Summary(Text(this method is unsafe)))))))
-@note:
-@see:
-body:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This is a test comment), Text(.)))), Text(
-))))))
-@example:Body(List(Paragraph(Chain(List(Summary(Monospace(Text("abb".permutations = Iterator(abb, bab, bba)))))))))
-@version:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(1), Text(.)))), Text(0, 09/07/2012))))))
-@since:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(2), Text(.)))), Text(10))))))
-@todo:Body(List(Paragraph(Chain(List(Summary(Text(this method is unsafe)))))))
-@note:Body(List(Paragraph(Chain(List(Summary(Text(Don't inherit!)))))))
-@see:
-body:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This is a test comment), Text(.)))), Text(
-))))))
-@example:Body(List(Paragraph(Chain(List(Summary(Monospace(Text("abb".permutations = Iterator(abb, bab, bba)))))))))
-@version:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(1), Text(.)))), Text(0, 09/07/2012))))))
-@since:Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(2), Text(.)))), Text(10))))))
-@todo:Body(List(Paragraph(Chain(List(Summary(Text(this method is unsafe)))))))
-@note:Body(List(Paragraph(Chain(List(Summary(Text(Don't inherit!)))))))
-@see:Body(List(Paragraph(Chain(List(Summary(Text(some other method)))))))
+reload: Base.scala, Class.scala, Derived.scala
diff --git a/test/files/presentation/doc/doc.scala b/test/files/presentation/doc/doc.scala
index f9ebd09876..d198f4c324 100755
--- a/test/files/presentation/doc/doc.scala
+++ b/test/files/presentation/doc/doc.scala
@@ -4,27 +4,40 @@ import scala.tools.nsc.doc.base.comment._
 import scala.tools.nsc.interactive._
 import scala.tools.nsc.interactive.tests._
 import scala.tools.nsc.util._
-import scala.tools.nsc.io._
 
 object Test extends InteractiveTest {
   val tags = Seq(
     "@example  `\"abb\".permutations = Iterator(abb, bab, bba)`",
     "@version 1.0, 09/07/2012",
     "@since 2.10",
-    "@todo this method is unsafe",
+    "@todo this is unsafe!",
     "@note Don't inherit!",
-    "@see some other method"
+    "@see something else"
   )
 
-  val comment = "This is a test comment."
-  val caret = "<caret>"
+  val names = Seq("Class", "Def", "Val", "Var", "AbstracType", "TypeAlias", "Trait", "InnerClass")
+  val bareText =
+    """abstract class %s {
+    |  def %s = ""
+    |  val %s = ""
+    |  var %s: String = _
+    |  type %s
+    |  type %s = String
+    |  class %s
+    |}
+    |trait %s""".stripMargin.format(names: _*)
+
+  def docComment(nTags: Int) = "/**\n%s*/".format(tags.take(nTags).mkString("\n"))
+
+  def text(name: String, nTags: Int) = {
+    val nameIndex = bareText.indexOf(name)
+    val (pre, post) = bareText.splitAt(nameIndex)
+    val crIndex = pre.lastIndexOf("\n")
+    val (prepre, prepost) = pre.splitAt(crIndex)
+    prepre + docComment(nTags) + prepost + post
+  }
+
 
-  def text(nTags: Int) = 
-    """|/** %s
-       |
-       | *  %s */
-       |trait Commented {}
-       |class User(c: %sCommented)""".stripMargin.format(comment, tags take nTags mkString "\n", caret)
 
   override lazy val compiler = {
     prepareSettings(settings)
@@ -44,9 +57,9 @@ object Test extends InteractiveTest {
 
       override def forScaladoc = true
 
-      def getComment(sym: Symbol, source: SourceFile) = {
+      def getComment(sym: Symbol, source: SourceFile, fragments: List[(Symbol,SourceFile)]): Option[Comment] = {
         val docResponse = new Response[(String, String, Position)]
-        askDocComment(sym, sym.owner, source, docResponse)
+        askDocComment(sym, source, sym.owner, fragments, docResponse)
         docResponse.get.left.toOption flatMap {
           case (expanded, raw, pos) =>
             if (expanded.isEmpty)
@@ -59,37 +72,74 @@ object Test extends InteractiveTest {
   }
 
   override def runDefaultTests() {
-    for (i <- 1 to tags.length) {
-      val markedText = text(i)
-      val idx = markedText.indexOf(caret)
-      val fileText = markedText.substring(0, idx) + markedText.substring(idx + caret.length)
-      val source = sourceFiles(0) 
-      val batch = new BatchSourceFile(source.file, fileText.toCharArray)
+    import compiler._
+    def findSource(name: String) = sourceFiles.find(_.file.name == name).get
+
+    val className = names.head
+    for (name <- names;
+         i <- 1 to tags.length) {
+      val newText = text(name, i)
+      val source = findSource("Class.scala")
+      val batch = new BatchSourceFile(source.file, newText.toCharArray)
       val reloadResponse = new Response[Unit]
       compiler.askReload(List(batch), reloadResponse)
       reloadResponse.get.left.toOption match {
         case None =>
-          reporter.println("Couldn't reload")
+          println("Couldn't reload")
         case Some(_) =>
-          val treeResponse = new compiler.Response[compiler.Tree]
-          val pos = compiler.rangePos(batch, idx, idx, idx)
-          compiler.askTypeAt(pos, treeResponse)
-          treeResponse.get.left.toOption match {
-            case Some(tree) =>
-              val sym = tree.tpe.typeSymbol
-              compiler.getComment(sym, batch) match {
-                case None => println("Got no doc comment")
+          val parseResponse = new Response[Tree]
+          askParsedEntered(batch, true, parseResponse)
+          parseResponse.get.left.toOption match {
+            case None =>
+              println("Couldn't parse")
+            case Some(_) =>
+              val sym = compiler.ask { () =>
+                val toplevel = definitions.EmptyPackage.info.decl(newTypeName(name))
+                if (toplevel eq NoSymbol) {
+                  val clazz = definitions.EmptyPackage.info.decl(newTypeName(className))
+
+                  val term = clazz.info.decl(newTermName(name))
+                  if (term eq NoSymbol) clazz.info.decl(newTypeName(name)) else
+                    if (term.isAccessor) term.accessed else term
+                } else toplevel
+              }
+
+              getComment(sym, batch, (sym,batch)::Nil) match {
+                case None => println(s"Got no doc comment for $name")
                 case Some(comment) =>
                   import comment._
-                  val tags: List[(String, Iterable[Body])] =
-                    List(("@example", example), ("@version", version), ("@since", since.toList), ("@todo", todo), ("@note",  note), ("@see", see))
-                  val str = ("body:" + body + "\n") + 
-                    tags.map{ case (name, bodies) => name + ":" + bodies.mkString("\n") }.mkString("\n")
-                  println(str)
+                  def cnt(bodies: Iterable[Body]) = bodies.size
+                  val actual = cnt(example) + cnt(version) + cnt(since) + cnt(todo) + cnt(note) + cnt(see)
+                  if (actual != i)
+                    println(s"Got docComment with $actual tags instead of $i, file text:\n$newText")
               }
-            case None => println("Couldn't find a typedTree")
           }
       }
     }
+
+    // Check inter-classes documentation one-time retrieved ok.
+    val baseSource = findSource("Base.scala")
+    val derivedSource = findSource("Derived.scala")
+    def existsText(where: Any, text: String): Boolean = where match {
+      case `text` => true
+      case s: Seq[_] => s exists (existsText(_, text))
+      case p: Product => p.productIterator exists (existsText(_, text))
+    }
+    val (derived, base) = compiler.ask { () => 
+      val derived = definitions.RootPackage.info.decl(newTermName("p")).info.decl(newTypeName("Derived"))
+      (derived, derived.ancestors(0))
+    }
+    val cmt1 = getComment(derived, derivedSource, (base, baseSource)::(derived, derivedSource)::Nil)
+    if (!existsText(cmt1, "Derived comment."))
+      println("Unexpected Derived class comment:"+cmt1)
+
+    val (fooDerived, fooBase) = compiler.ask { () =>
+      val decl = derived.tpe.decl(newTermName("foo"))
+      (decl, decl.allOverriddenSymbols(0))
+    }
+
+    val cmt2 = getComment(fooDerived, derivedSource, (fooBase, baseSource)::(fooDerived, derivedSource)::Nil)
+    if (!existsText(cmt2, "Base method has documentation."))
+      println("Unexpected foo method comment:"+cmt2)
   }
 }
diff --git a/test/files/presentation/doc/src/Class.scala b/test/files/presentation/doc/src/Class.scala
new file mode 100755
index 0000000000..a974bd6f5c
--- /dev/null
+++ b/test/files/presentation/doc/src/Class.scala
@@ -0,0 +1 @@
+object Class
\ No newline at end of file
diff --git a/test/files/presentation/doc/src/Test.scala b/test/files/presentation/doc/src/Test.scala
deleted file mode 100755
index fcc1554994..0000000000
--- a/test/files/presentation/doc/src/Test.scala
+++ /dev/null
@@ -1 +0,0 @@
-object Test
\ No newline at end of file
diff --git a/test/files/presentation/doc/src/p/Base.scala b/test/files/presentation/doc/src/p/Base.scala
new file mode 100755
index 0000000000..9031de3e3e
--- /dev/null
+++ b/test/files/presentation/doc/src/p/Base.scala
@@ -0,0 +1,11 @@
+package p
+
+/**
+ * @define BaseComment $BaseVar comment.
+ */
+trait Base {
+  /**
+   * Base method has documentation.
+   */
+  def foo: String
+}
diff --git a/test/files/presentation/doc/src/p/Derived.scala b/test/files/presentation/doc/src/p/Derived.scala
new file mode 100755
index 0000000000..1a9c9a26d1
--- /dev/null
+++ b/test/files/presentation/doc/src/p/Derived.scala
@@ -0,0 +1,9 @@
+package p
+
+/**
+ * $BaseComment
+ * @define BaseVar Derived
+ */
+class Derived extends Base {
+  def foo = ""
+}