Removed code from scaladoc.

Nobody is immune!

Author: paulp

src/compiler/scala/tools/nsc/ast/DocComments.scala

@@ -21,11 +21,6 @@ trait DocComments { self: Global =>
   /** The raw doc comment map */
   val docComments = mutable.HashMap[Symbol, DocComment]()
 
-  /** Associate comment with symbol `sym` at position `pos`. */
-  def docComment(sym: Symbol, docStr: String, pos: Position = NoPosition) =
-    if ((sym ne null) && (sym ne NoSymbol))
-      docComments += (sym -> DocComment(docStr, pos))
-
   /** The raw doc comment of symbol `sym`, as it appears in the source text, "" if missing.
    */
   def rawDocComment(sym: Symbol): String =
@@ -120,8 +115,6 @@ trait DocComments { self: Global =>
     getDocComment(sym) map getUseCases getOrElse List()
   }
 
-  def useCases(sym: Symbol): List[(Symbol, String, Position)] = useCases(sym, sym.enclClass)
-
   /** Returns the javadoc format of doc comment string `s`, including wiki expansion
    */
   def toJavaDoc(s: String): String = expandWiki(s)

src/compiler/scala/tools/nsc/doc/html/Page.scala

@@ -88,12 +88,6 @@ abstract class Page {
   def relativeLinkTo(destClass: TemplateEntity): String =
     relativeLinkTo(templateToPath(destClass))
 
-  /** A relative link from this page to some destination page in the Scaladoc site.
-    * @param destPage The page that the link will point to. */
-  def relativeLinkTo(destPage: HtmlPage): String = {
-    relativeLinkTo(destPage.path)
-  }
-
   /** A relative link from this page to some destination path.
     * @param destPath The path that the link will point to. */
   def relativeLinkTo(destPath: List[String]): String = {

src/compiler/scala/tools/nsc/doc/model/Entity.scala

@@ -23,10 +23,6 @@ import diagram._
   *  - type and value parameters;
   *  - annotations. */
 trait Entity {
-
-  /** Similar to symbols, so we can track entities */
-  def id: Int
-
   /** The name of the entity. Note that the name does not qualify this entity uniquely; use its `qualifiedName`
     * instead. */
   def name : String
@@ -59,9 +55,6 @@ trait Entity {
 
   /** Indicates whether this entity lives in the types namespace (classes, traits, abstract/alias types) */
   def isType: Boolean
-
-  /** Indicates whether this entity lives in the terms namespace (objects, packages, methods, values) */
-  def isTerm: Boolean
 }
 
 object Entity {
@@ -97,9 +90,6 @@ trait TemplateEntity extends Entity {
   /** Whether documentation is available for this template. */
   def isDocTemplate: Boolean
 
-  /** Whether documentation is available for this template. */
-  def isNoDocMemberTemplate: Boolean
-
   /** Whether this template is a case class. */
   def isCaseClass: Boolean
 
@@ -174,12 +164,6 @@ trait MemberEntity extends Entity {
   /** Whether this member is an abstract type. */
   def isAbstractType: Boolean
 
-  /** Whether this member is a template. */
-  def isTemplate: Boolean
-
-  /** Whether this member is implicit.  */
-  def isImplicit: Boolean
-
   /** Whether this member is abstract. */
   def isAbstract: Boolean
 
@@ -381,14 +365,9 @@ trait RootPackage extends Package
 
 /** A non-template member (method, value, lazy value, variable, constructor, alias type, and abstract type). */
 trait NonTemplateMemberEntity extends MemberEntity {
-
   /** Whether this member is a use case. A use case is a member which does not exist in the documented code.
     * It corresponds to a real member, and provides a simplified, yet compatible signature for that member. */
   def isUseCase: Boolean
-
-  /** Whether this member is a bridge member. A bridge member does only exist for binary compatibility reasons
-    * and should not appear in ScalaDoc. */
-  def isBridge: Boolean
 }
 
 
@@ -503,12 +482,6 @@ trait ImplicitConversion {
   /** The result type after the conversion */
   def targetType: TypeEntity
 
-  /** The result type after the conversion
-   *  Note: not all targetTypes have a corresponding template. Examples include conversions resulting in refinement
-   *  types. Need to check it's not option!
-   */
-  def targetTemplate: Option[TemplateEntity]
-
   /** The components of the implicit conversion type parents */
   def targetTypeComponents: List[(TemplateEntity, TypeEntity)]
 

src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala

@@ -17,8 +17,6 @@ object IndexModelFactory {
 
       object result extends mutable.HashMap[Char,SymbolMap] {
 
-        /* Owner template ordering */
-        implicit def orderingSet = math.Ordering.String.on { x: MemberEntity => x.name.toLowerCase }
         /* symbol name ordering */
         implicit def orderingMap = math.Ordering.String.on { x: String => x.toLowerCase }
 

src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala

@@ -43,11 +43,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
   def modelFinished: Boolean = _modelFinished
   private var universe: Universe = null
 
-  protected def closestPackage(sym: Symbol) = {
-    if (sym.isPackage || sym.isPackageClass) sym
-    else sym.enclosingPackage
-  }
-
   def makeModel: Option[Universe] = {
     val universe = new Universe { thisUniverse =>
       thisFactory.universe = thisUniverse
@@ -77,7 +72,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
   /* ============== IMPLEMENTATION PROVIDING ENTITY TYPES ============== */
 
   abstract class EntityImpl(val sym: Symbol, val inTpl: TemplateImpl) extends Entity {
-    val id = { ids += 1; ids }
     val name = optimize(sym.nameString)
     val universe = thisFactory.universe
 
@@ -91,7 +85,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     def annotations = sym.annotations.map(makeAnnotation)
     def inPackageObject: Boolean = sym.owner.isModuleClass && sym.owner.sourceModule.isPackageObject
     def isType = sym.name.isTypeName
-    def isTerm = sym.name.isTermName
   }
 
   trait TemplateImpl extends EntityImpl with TemplateEntity {
@@ -103,7 +96,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     def isObject = sym.isModule && !sym.isPackage
     def isCaseClass = sym.isCaseClass
     def isRootPackage = false
-    def isNoDocMemberTemplate = false
     def selfType = if (sym.thisSym eq sym) None else Some(makeType(sym.thisSym.typeOfThis, this))
   }
 
@@ -178,9 +170,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
         })
       else
         None
-    def inheritedFrom =
-      if (inTemplate.sym == this.sym.owner || inTemplate.sym.isPackage) Nil else
-        makeTemplate(this.sym.owner) :: (sym.allOverriddenSymbols map { os => makeTemplate(os.owner) })
+
     def resultType = {
       def resultTpe(tpe: Type): Type = tpe match { // similar to finalResultType, except that it leaves singleton types alone
         case PolyType(_, res) => resultTpe(res)
@@ -195,15 +185,14 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     def isVal = false
     def isLazyVal = false
     def isVar = false
-    def isImplicit = sym.isImplicit
     def isConstructor = false
     def isAliasType = false
     def isAbstractType = false
     def isAbstract =
       // for the explanation of conversion == null see comment on flags
       ((!sym.isTrait && ((sym hasFlag Flags.ABSTRACT) || (sym hasFlag Flags.DEFERRED)) && (!isImplicitlyInherited)) ||
       sym.isAbstractClass || sym.isAbstractType) && !sym.isSynthetic
-    def isTemplate = false
+
     def signature = externalSignature(sym)
     lazy val signatureCompat = {
 
@@ -257,25 +246,10 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
    */
   abstract class MemberTemplateImpl(sym: Symbol, inTpl: DocTemplateImpl) extends MemberImpl(sym, inTpl) with TemplateImpl with HigherKindedImpl with MemberTemplateEntity {
     // no templates cache for this class, each owner gets its own instance
-    override def isTemplate = true
     def isDocTemplate = false
-    override def isNoDocMemberTemplate = true
     lazy val definitionName = optimize(inDefinitionTemplates.head.qualifiedName + "." + name)
     def valueParams: List[List[ValueParam]] = Nil /** TODO, these are now only computed for DocTemplates */
 
-    // Seems unused
-    // def parentTemplates =
-    //   if (sym.isPackage || sym == AnyClass)
-    //     List()
-    //   else
-    //     sym.tpe.parents.flatMap { tpe: Type =>
-    //       val tSym = tpe.typeSymbol
-    //       if (tSym != NoSymbol)
-    //         List(makeTemplate(tSym))
-    //       else
-    //         List()
-    //     } filter (_.isInstanceOf[DocTemplateEntity])
-
     def parentTypes =
       if (sym.isPackage || sym == AnyClass) List() else {
         val tps = (this match {
@@ -380,9 +354,9 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     lazy val memberSyms      = sym.info.members.filter(s => membersShouldDocument(s, this)).toList
 
     // the inherited templates (classes, traits or objects)
-    var memberSymsLazy  = memberSyms.filter(t => templateShouldDocument(t, this) && !inOriginalOwner(t, this))
+    val memberSymsLazy  = memberSyms.filter(t => templateShouldDocument(t, this) && !inOriginalOwner(t, this))
     // the direct members (methods, values, vars, types and directly contained templates)
-    var memberSymsEager = memberSyms.filter(!memberSymsLazy.contains(_))
+    val memberSymsEager = memberSyms.filter(!memberSymsLazy.contains(_))
     // the members generated by the symbols in memberSymsEager
     val ownMembers      = (memberSymsEager.flatMap(makeMember(_, None, this)))
 
@@ -438,7 +412,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
         else List()
       )
 
-    override def isTemplate = true
     override def isDocTemplate = true
     private[this] lazy val companionSymbol =
       if (sym.isAliasType || sym.isAbstractType) {
@@ -545,7 +518,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
       val qualifiedName = conversion.fold(inDefinitionTemplates.head.qualifiedName)(_.conversionQualifiedName)
       optimize(qualifiedName + "#" + name)
     }
-    def isBridge = sym.isBridge
     def isUseCase = useCaseOf.isDefined
     override def byConversion: Option[ImplicitConversionImpl] = conversion
     override def isImplicitlyInherited = { assert(modelFinished); conversion.isDefined }
@@ -707,7 +679,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
           override def inTemplate = this
           override def toRoot = this :: Nil
           override def qualifiedName = "_root_"
-          override def inheritedFrom = Nil
           override def isRootPackage = true
           override lazy val memberSyms =
             (bSym.info.members ++ EmptyPackage.info.members).toList filter { s =>
@@ -857,12 +828,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     inTpl.members.find(_.sym == aSym)
   }
 
-  @deprecated("Use `findLinkTarget` instead.", "2.10.0")
-  def findTemplate(query: String): Option[DocTemplateImpl] = {
-    assert(modelFinished)
-    docTemplatesCache.values find { (tpl: DocTemplateImpl) => tpl.qualifiedName == query && !packageDropped(tpl) && !tpl.isObject }
-  }
-
   def findTemplateMaybe(aSym: Symbol): Option[DocTemplateImpl] = {
     assert(modelFinished)
     docTemplatesCache.get(normalizeTemplate(aSym)).filterNot(packageDropped(_))

src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala

@@ -345,15 +345,6 @@ trait ModelFactoryImplicitSupport {
         makeRootPackage
       }
 
-    def targetTemplate: Option[TemplateEntity] = toType match {
-      // @Vlad: I'm being extra conservative in template creation -- I don't want to create templates for complex types
-      // such as refinement types because the template can't represent the type corectly (a template corresponds to a
-      // package, class, trait or object)
-      case t: TypeRef => Some(makeTemplate(t.sym))
-      case RefinedType(parents, decls) => None
-      case _ => error("Scaladoc implicits: Could not create template for: " + toType + " of type " + toType.getClass); None
-    }
-
     def targetTypeComponents: List[(TemplateEntity, TypeEntity)] = makeParentTypes(toType, None, inTpl)
 
     def convertorMethod: Either[MemberEntity, String] = {
@@ -492,14 +483,14 @@ trait ModelFactoryImplicitSupport {
   /**
    *  Make implicits explicit - Not used curently
    */
-  object implicitToExplicit extends TypeMap {
-    def apply(tp: Type): Type = mapOver(tp) match {
-      case MethodType(params, resultType) =>
-        MethodType(params.map(param => if (param.isImplicit) param.cloneSymbol.resetFlag(Flags.IMPLICIT) else param), resultType)
-      case other =>
-        other
-    }
-  }
+  // object implicitToExplicit extends TypeMap {
+  //   def apply(tp: Type): Type = mapOver(tp) match {
+  //     case MethodType(params, resultType) =>
+  //       MethodType(params.map(param => if (param.isImplicit) param.cloneSymbol.resetFlag(Flags.IMPLICIT) else param), resultType)
+  //     case other =>
+  //       other
+  //   }
+  // }
 
   /**
    * removeImplicitParameters transforms implicit parameters from the view result type into constraints and

src/compiler/scala/tools/nsc/doc/model/comment/Comment.scala

@@ -102,9 +102,6 @@ abstract class Comment {
   /** A usage example related to the entity. */
   def example: List[Body]
 
-  /** The comment as it appears in the source text. */
-  def source: Option[String]
-
   /** A description for the primary constructor */
   def constructor: Option[Body]
 

src/compiler/scala/tools/nsc/doc/model/comment/CommentFactory.scala

@@ -28,11 +28,6 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory with Member
 
   protected val commentCache = mutable.HashMap.empty[(global.Symbol, TemplateImpl), Comment]
 
-  def addCommentBody(sym: global.Symbol, inTpl: TemplateImpl, docStr: String, docPos: global.Position): global.Symbol = {
-    commentCache += (sym, inTpl) -> parse(docStr, docStr, docPos, None)
-    sym
-  }
-
   def comment(sym: global.Symbol, currentTpl: Option[DocTemplateImpl], inTpl: DocTemplateImpl): Option[Comment] = {
     val key = (sym, inTpl)
     if (commentCache isDefinedAt key)
@@ -132,7 +127,6 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory with Member
     val note           = note0
     val example        = example0
     val constructor    = constructor0
-    val source         = source0
     val inheritDiagram = inheritDiagram0
     val contentDiagram = contentDiagram0
     val groupDesc      = groupDesc0
@@ -957,20 +951,6 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory with Member
       count
     }
 
-    final def jumpUntil(chars: String): Int = {
-      assert(chars.length > 0)
-      var count = 0
-      val c = chars.charAt(0)
-      while (!check(chars) && char != endOfText) {
-        nextChar()
-        while (char != c && char != endOfText) {
-          nextChar()
-          count += 1
-        }
-      }
-      count
-    }
-
     final def jumpUntil(pred: => Boolean): Int = {
       var count = 0
       while (!pred && char != endOfText) {

src/compiler/scala/tools/nsc/doc/model/diagram/Diagram.scala

@@ -36,20 +36,12 @@ case class InheritanceDiagram(thisNode: ThisNode,
   override def isInheritanceDiagram = true
   lazy val depthInfo = new DepthInfo {
     def maxDepth = 3
-    def nodeDepth(node: Node) =
-      if (node == thisNode) 1
-      else if (superClasses.contains(node)) 0
-      else if (subClasses.contains(node)) 2
-      else if (incomingImplicits.contains(node) || outgoingImplicits.contains(node)) 1
-      else -1
   }
 }
 
 trait DepthInfo {
   /** Gives the maximum depth */
   def maxDepth: Int
-  /** Gives the depth of any node in the diagram or -1 if the node is not in the diagram */
-  def nodeDepth(node: Node): Int
 }
 
 abstract class Node {
@@ -142,5 +134,4 @@ class ContentDiagramDepth(pack: ContentDiagram) extends DepthInfo {
   }
 
   val maxDepth = _maxDepth
-  def nodeDepth(node: Node) = _nodeDepth.getOrElse(node, -1)
-}
+}