1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/* NSC -- new Scala compiler
* Copyright 2007-2010 LAMP/EPFL
* @author Manohar Jonnalagedda
*/
package scala.tools.nsc
package doc
package model
import scala.collection._
import comment._
/** Some entity of the Scaladoc model. */
trait Entity {
def name : String
def inTemplate: TemplateEntity
def toRoot: List[Entity]
def qualifiedName: String
override def toString = qualifiedName
}
/** A class, trait, object or package. A package is represented as an instance of the `Package` subclass. A class,
* trait, object or package may be directly an instance of `WeakTemplateEntity` if it is not ''documentable'' (that
* is, if there is no documentation page for it in the current site), otherwise, it will be represented as an instance
* of the `TemplateEntity` subclass. */
trait TemplateEntity extends Entity {
def isPackage: Boolean
def isRootPackage: Boolean
def isTrait: Boolean
def isClass: Boolean
def isObject: Boolean
def isDocTemplate: Boolean
}
trait NoDocTemplate extends TemplateEntity
/** A member of a class, trait, object or package. */
trait MemberEntity extends Entity {
def comment: Option[Comment]
def inTemplate: DocTemplateEntity
def toRoot: List[MemberEntity]
def inDefinitionTemplates: List[TemplateEntity]
def definitionName: String
def visibility: Visibility
def flags: List[Paragraph]
def deprecation: Option[Body]
def inheritedFrom: List[TemplateEntity]
def resultType: TypeEntity
def isDef: Boolean
def isVal: Boolean
def isVar: Boolean
def isConstructor: Boolean
def isAliasType: Boolean
def isAbstractType: Boolean
def isTemplate: Boolean
}
/** A ''documentable'' class, trait or object (that is, a documentation page will be generated for it in the current
* site). */
trait DocTemplateEntity extends TemplateEntity with MemberEntity {
def toRoot: List[DocTemplateEntity]
def inSource: Option[(io.AbstractFile, Int)]
def sourceUrl: Option[java.net.URL]
def typeParams: List[TypeParam]
def parentType: Option[TypeEntity]
def linearization: List[TemplateEntity]
def subClasses: List[DocTemplateEntity]
def members: List[MemberEntity]
def templates: List[DocTemplateEntity]
def methods: List[Def]
def values: List[Val]
def abstractTypes: List[AbstractType]
def aliasTypes: List[AliasType]
def companion: Option[DocTemplateEntity]
// temporary implementation: to be removed
def findMember(str: String): Option[DocTemplateEntity] = {
val root = toRoot.last
val path = if (str.length > 0) str.split("\\.") else Array[String]()
var i = 0;
var found: DocTemplateEntity = root
while(i < path.length && found != null) {
found = found.members.find(_.name == path(i)) match {
case Some(doc:DocTemplateEntity) => doc
case _ => null
}
i += 1
}
Option(found)
}
}
/** A ''documentable'' trait. */
trait Trait extends DocTemplateEntity {
def valueParams : List[List[ValueParam]]
}
/** A ''documentable'' class. */
trait Class extends Trait {
def primaryConstructor: Option[Constructor]
def constructors: List[Constructor]
def isCaseClass: Boolean
}
/** A ''documentable'' object. */
trait Object extends DocTemplateEntity
/** A package that contains at least one ''documentable'' class, trait, object or package. */
trait Package extends Object {
def inTemplate: Package
def toRoot: List[Package]
def packages: List[Package]
}
/** A package represent the root of Entities hierarchy */
trait RootPackage extends Package
trait NonTemplateMemberEntity extends MemberEntity {
def isUseCase: Boolean
}
/** A method (`def`) of a ''documentable'' class, trait or object. */
trait Def extends NonTemplateMemberEntity {
def typeParams: List[TypeParam]
def valueParams : List[List[ValueParam]]
}
trait Constructor extends NonTemplateMemberEntity {
def isPrimary: Boolean
def valueParams : List[List[ValueParam]]
}
/** A value (`val`) or variable (`var`) of a ''documentable'' class, trait or object. */
trait Val extends NonTemplateMemberEntity
/** An abstract type of a ''documentable'' class, trait or object. */
trait AbstractType extends NonTemplateMemberEntity {
// TODO: typeParams
def lo: Option[TypeEntity]
def hi: Option[TypeEntity]
}
/** An abstract type of a ''documentable'' class, trait or object. */
trait AliasType extends NonTemplateMemberEntity {
// TODO: typeParams
def alias: TypeEntity
}
trait ParameterEntity extends Entity {
def inTemplate: DocTemplateEntity
def isTypeParam: Boolean
def isValueParam: Boolean
}
/** A type parameter to a class or trait or to a method. */
trait TypeParam extends ParameterEntity {
def variance: String
def lo: Option[TypeEntity]
def hi: Option[TypeEntity]
}
/** A value parameter to a constructor or to a method. */
trait ValueParam extends ParameterEntity {
def resultType: TypeEntity
def defaultValue: Option[String]
def isImplicit: Boolean
}
/** An type that represents visibility of members. */
sealed trait Visibility {
def isProtected: Boolean = false
def isPublic: Boolean = false
}
/** The visibility of `private[this]` members. */
case class PrivateInInstance extends Visibility
/** The visibility of `protected[this]` members. */
case class ProtectedInInstance extends Visibility {
override def isProtected = true
}
/** The visibility of `private[owner]` members. An unqualified private members is encoded with `owner` equal to the
* members's `inTemplate`. */
case class PrivateInTemplate(owner: TemplateEntity) extends Visibility
/** The visibility of `protected[owner]` members. An unqualified protected members is encoded with `owner` equal to the
* members's `inTemplate`.
* Note that whilst the member is visible in any template owned by `owner`, it is only visible in subclasses of the
* member's `inTemplate`. */
case class ProtectedInTemplate(owner: TemplateEntity) extends Visibility {
override def isProtected = true
}
/** The visibility of public members. */
case class Public extends Visibility {
override def isPublic = true
}
|
