Instance Constructors
-
new
DocParser()
-
new
DocParser(settings: Settings)
-
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(other: String): String
-
def
->[B](y: B): (DocParser, B)
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
object
Alternative extends reflect.internal.SymbolTable.AlternativeExtractor with Serializable
-
implicit
val
AlternativeTag: ClassTag[Alternative]
-
object
Annotated extends reflect.internal.SymbolTable.AnnotatedExtractor with Serializable
-
implicit
val
AnnotatedTag: ClassTag[Annotated]
-
object
AnnotatedType extends reflect.internal.SymbolTable.AnnotatedTypeExtractor with Serializable
-
implicit
val
AnnotatedTypeTag: ClassTag[AnnotatedType]
-
object
AnnotationInfo
-
implicit
val
AnnotationTag: ClassTag[AnnotationInfo]
-
object
AppliedTypeTree extends reflect.internal.SymbolTable.AppliedTypeTreeExtractor with Serializable
-
implicit
val
AppliedTypeTreeTag: ClassTag[AppliedTypeTree]
-
-
object
Apply extends reflect.internal.SymbolTable.ApplyExtractor with Serializable
-
def
ApplyConstructor(tpt: Tree, args: List[Tree]): Apply
-
implicit
val
ApplyTag: ClassTag[Apply]
-
object
ApproximateDependentMap extends reflect.internal.SymbolTable.TypeMap
-
object
ArrayAnnotArg extends reflect.internal.SymbolTable.ArrayArgumentExtractor with Serializable
-
-
implicit
val
ArrayArgumentTag: ClassTag[ArrayAnnotArg]
-
object
Assign extends reflect.internal.SymbolTable.AssignExtractor with Serializable
-
object
AssignOrNamedArg extends reflect.internal.SymbolTable.AssignOrNamedArgExtractor with Serializable
-
implicit
val
AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]
-
implicit
val
AssignTag: ClassTag[Assign]
-
object
BackquotedIdentifierAttachment extends Product with Serializable
-
-
object
Bind extends reflect.internal.SymbolTable.BindExtractor with Serializable
-
implicit
val
BindTag: ClassTag[Bind]
-
def
Block(stats: Tree*): Block
-
object
Block extends reflect.internal.SymbolTable.BlockExtractor with Serializable
-
implicit
val
BlockTag: ClassTag[Block]
-
object
BooleanFlag extends Serializable
-
final
val
BooleanTag: Int(2)
-
object
BoundedWildcardType extends reflect.internal.SymbolTable.BoundedWildcardTypeExtractor with Serializable
-
implicit
val
BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]
-
final
val
ByteTag: Int(3)
-
-
object
CaseDef extends reflect.internal.SymbolTable.CaseDefExtractor with Serializable
-
implicit
val
CaseDefTag: ClassTag[CaseDef]
-
final
val
CharTag: Int(5)
-
-
-
object
ClassDef extends reflect.internal.SymbolTable.ClassDefExtractor with Serializable
-
implicit
val
ClassDefTag: ClassTag[ClassDef]
-
object
ClassInfoType extends reflect.internal.SymbolTable.ClassInfoTypeExtractor with Serializable
-
implicit
val
ClassInfoTypeTag: ClassTag[ClassInfoType]
-
implicit
val
ClassSymbolTag: ClassTag[ClassSymbol]
-
final
val
ClazzTag: Int(12)
-
implicit
val
CompoundTypeTag: ClassTag[CompoundType]
-
object
CompoundTypeTree extends reflect.internal.SymbolTable.CompoundTypeTreeExtractor with Serializable
-
implicit
val
CompoundTypeTreeTag: ClassTag[CompoundTypeTree]
-
object
ConsoleWriter extends Writer
-
object
Constant extends reflect.internal.SymbolTable.ConstantExtractor with Serializable
-
implicit
val
ConstantTag: ClassTag[Constant]
-
object
ConstantType extends reflect.internal.SymbolTable.ConstantTypeExtractor with Serializable
-
implicit
val
ConstantTypeTag: ClassTag[ConstantType]
-
val
CyclicInheritance: java.lang.Throwable
-
-
-
-
-
-
-
object
DefDef extends reflect.internal.SymbolTable.DefDefExtractor with Serializable
-
implicit
val
DefDefTag: ClassTag[DefDef]
-
implicit
val
DefTreeTag: ClassTag[DefTree]
-
final
val
DoubleTag: Int(9)
-
def
EmptyPackageClass: ClassSymbol
-
object
EmptyScope extends reflect.internal.SymbolTable.Scope
-
object
EmptyTree extends reflect.internal.SymbolTable.Tree with reflect.internal.SymbolTable.TermTree with Product with Serializable
-
-
final
val
EnumTag: Int(13)
-
object
ErasedValueType extends Serializable
-
object
ErrorType extends reflect.internal.SymbolTable.Type with Product with Serializable
-
object
ExistentialType extends reflect.internal.SymbolTable.ExistentialTypeExtractor with Serializable
-
implicit
val
ExistentialTypeTag: ClassTag[ExistentialType]
-
object
ExistentialTypeTree extends reflect.internal.SymbolTable.ExistentialTypeTreeExtractor with Serializable
-
implicit
val
ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]
-
object
Expr extends Serializable
-
object
Flag extends reflect.internal.SymbolTable.FlagValues
-
implicit
val
FlagSetTag: ClassTag[FlagSet]
-
final
val
FloatTag: Int(8)
-
implicit
val
FreeTermSymbolTag: ClassTag[FreeTermSymbol]
-
implicit
val
FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
-
object
Function extends reflect.internal.SymbolTable.FunctionExtractor with Serializable
-
implicit
val
FunctionTag: ClassTag[Function]
-
object
GenPolyType
-
implicit
val
GenericApplyTag: ClassTag[GenericApply]
-
val
GlbFailure: java.lang.Throwable
-
-
def
Ident(name: String): Ident
-
object
Ident extends reflect.internal.SymbolTable.IdentExtractor with Serializable
-
implicit
val
IdentTag: ClassTag[Ident]
-
object
If extends reflect.internal.SymbolTable.IfExtractor with Serializable
-
implicit
val
IfTag: ClassTag[If]
-
implicit
val
ImplDefTag: ClassTag[ImplDef]
-
object
Import extends reflect.internal.SymbolTable.ImportExtractor with Serializable
-
object
ImportSelector extends reflect.internal.SymbolTable.ImportSelectorExtractor with Serializable
-
implicit
val
ImportSelectorTag: ClassTag[ImportSelector]
-
implicit
val
ImportTag: ClassTag[Import]
-
final
val
IntTag: Int(6)
-
implicit
val
JavaArgumentTag: ClassTag[ClassfileAnnotArg]
-
-
-
object
LabelDef extends reflect.internal.SymbolTable.LabelDefExtractor with Serializable
-
implicit
val
LabelDefTag: ClassTag[LabelDef]
-
object
Literal extends reflect.internal.SymbolTable.LiteralExtractor with Serializable
-
object
LiteralAnnotArg extends reflect.internal.SymbolTable.LiteralArgumentExtractor with Serializable
-
-
implicit
val
LiteralArgumentTag: ClassTag[LiteralAnnotArg]
-
implicit
val
LiteralTag: ClassTag[Literal]
-
final
val
LongTag: Int(7)
-
object
Match extends reflect.internal.SymbolTable.MatchExtractor with Serializable
-
implicit
val
MatchTag: ClassTag[Match]
-
val
MaxPhases: Int
-
implicit
val
MemberDefTag: ClassTag[MemberDef]
-
implicit
val
MemberScopeTag: ClassTag[MemberScope]
-
implicit
val
MethodSymbolTag: ClassTag[MethodSymbol]
-
object
MethodType extends reflect.internal.SymbolTable.MethodTypeExtractor with Serializable
-
implicit
val
MethodTypeTag: ClassTag[MethodType]
-
-
def
Modifiers(flags: FlagSet, privateWithin: Name): Modifiers
-
object
Modifiers extends reflect.internal.SymbolTable.ModifiersCreator with Serializable
-
implicit
val
ModifiersTag: ClassTag[Modifiers]
-
-
object
ModuleDef extends reflect.internal.SymbolTable.ModuleDefExtractor with Serializable
-
implicit
val
ModuleDefTag: ClassTag[ModuleDef]
-
implicit
val
ModuleSymbolTag: ClassTag[ModuleSymbol]
-
implicit
val
NameTag: ClassTag[Name]
-
implicit
val
NameTreeTag: ClassTag[NameTree]
-
object
NestedAnnotArg extends reflect.internal.SymbolTable.NestedArgumentExtractor with Serializable
-
-
implicit
val
NestedArgumentTag: ClassTag[NestedAnnotArg]
-
-
def
New(tpe: Type, args: Tree*): Tree
-
-
object
New extends reflect.internal.SymbolTable.NewExtractor with Serializable
-
implicit
val
NewTag: ClassTag[New]
-
-
-
-
-
final
val
NoPeriod: Int(0)
-
val
NoPosition: reflect.internal.util.NoPosition.type
-
object
NoPrefix extends reflect.internal.SymbolTable.Type with Product with Serializable
-
final
val
NoRunId: Int(0)
-
lazy val
NoSymbol: NoSymbol
-
final
val
NoTag: Int(0)
-
object
NoType extends reflect.internal.SymbolTable.Type with Product with Serializable
-
final
val
NullTag: Int(11)
-
object
NullaryMethodType extends reflect.internal.SymbolTable.NullaryMethodTypeExtractor with Serializable
-
implicit
val
NullaryMethodTypeTag: ClassTag[NullaryMethodType]
-
object
PackageDef extends reflect.internal.SymbolTable.PackageDefExtractor with Serializable
-
implicit
val
PackageDefTag: ClassTag[PackageDef]
-
object
PolyType extends reflect.internal.SymbolTable.PolyTypeExtractor with Serializable
-
implicit
val
PolyTypeTag: ClassTag[PolyType]
-
implicit
val
PositionTag: ClassTag[Position]
-
implicit
val
RefTreeTag: ClassTag[RefTree]
-
object
ReferenceToBoxed extends reflect.internal.SymbolTable.ReferenceToBoxedExtractor with Serializable
-
implicit
val
ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
-
object
RefinedType extends reflect.internal.SymbolTable.RefinedTypeExtractor with Serializable
-
implicit
val
RefinedTypeTag: ClassTag[RefinedType]
-
object
Return extends reflect.internal.SymbolTable.ReturnExtractor with Serializable
-
implicit
val
ReturnTag: ClassTag[Return]
-
-
object
Scope
-
implicit
val
ScopeTag: ClassTag[Scope]
-
-
def
Select(qualifier: Tree, name: String): Select
-
object
Select extends reflect.internal.SymbolTable.SelectExtractor with Serializable
-
object
SelectFromTypeTree extends reflect.internal.SymbolTable.SelectFromTypeTreeExtractor with Serializable
-
implicit
val
SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]
-
implicit
val
SelectTag: ClassTag[Select]
-
final
val
ShortTag: Int(4)
-
object
SingleType extends reflect.internal.SymbolTable.SingleTypeExtractor with Serializable
-
implicit
val
SingleTypeTag: ClassTag[SingleType]
-
implicit
val
SingletonTypeTag: ClassTag[SingletonType]
-
object
SingletonTypeTree extends reflect.internal.SymbolTable.SingletonTypeTreeExtractor with Serializable
-
implicit
val
SingletonTypeTreeTag: ClassTag[SingletonTypeTree]
-
object
Star extends reflect.internal.SymbolTable.StarExtractor with Serializable
-
implicit
val
StarTag: ClassTag[Star]
-
implicit
val
StringContextStripMarginOps: (StringContext) ⇒ StringContextStripMarginOps
-
final
val
StringTag: Int(10)
-
-
object
Super extends reflect.internal.SymbolTable.SuperExtractor with Serializable
-
implicit
val
SuperTag: ClassTag[Super]
-
object
SuperType extends reflect.internal.SymbolTable.SuperTypeExtractor with Serializable
-
implicit
val
SuperTypeTag: ClassTag[SuperType]
-
object
SuppressMacroExpansionAttachment extends Product with Serializable
-
implicit
val
SymTreeTag: ClassTag[SymTree]
-
implicit
val
SymbolTag: ClassTag[Symbol]
-
-
object
Template extends reflect.internal.SymbolTable.TemplateExtractor with Serializable
-
implicit
val
TemplateTag: ClassTag[Template]
-
-
implicit
val
TermNameTag: ClassTag[TermName]
-
implicit
val
TermSymbolTag: ClassTag[TermSymbol]
-
implicit
val
TermTreeTag: ClassTag[TermTree]
-
-
object
This extends reflect.internal.SymbolTable.ThisExtractor with Serializable
-
implicit
val
ThisTag: ClassTag[This]
-
object
ThisType extends reflect.internal.SymbolTable.ThisTypeExtractor with Serializable
-
implicit
val
ThisTypeTag: ClassTag[ThisType]
-
def
Throw(tpe: Type, args: Tree*): Throw
-
object
Throw extends reflect.internal.SymbolTable.ThrowExtractor with Serializable
-
implicit
val
ThrowTag: ClassTag[Throw]
-
object
ThrownException
-
implicit
val
TreeTag: ClassTag[Tree]
-
def
Try(body: Tree, cases: (Tree, Tree)*): Try
-
object
Try extends reflect.internal.SymbolTable.TryExtractor with Serializable
-
implicit
val
TryTag: ClassTag[Try]
-
implicit
val
TypTreeTag: ClassTag[TypTree]
-
object
TypeApply extends reflect.internal.SymbolTable.TypeApplyExtractor with Serializable
-
implicit
val
TypeApplyTag: ClassTag[TypeApply]
-
object
TypeBounds extends reflect.internal.SymbolTable.TypeBoundsExtractor with Serializable
-
implicit
val
TypeBoundsTag: ClassTag[TypeBounds]
-
object
TypeBoundsTree extends reflect.internal.SymbolTable.TypeBoundsTreeExtractor with Serializable
-
implicit
val
TypeBoundsTreeTag: ClassTag[TypeBoundsTree]
-
-
-
object
TypeDef extends reflect.internal.SymbolTable.TypeDefExtractor with Serializable
-
implicit
val
TypeDefTag: ClassTag[TypeDef]
-
-
implicit
val
TypeNameTag: ClassTag[TypeName]
-
object
TypeRef extends reflect.internal.SymbolTable.TypeRefExtractor with Serializable
-
implicit
val
TypeRefTag: ClassTag[TypeRef]
-
implicit
val
TypeSymbolTag: ClassTag[TypeSymbol]
-
object
TypeTag extends Serializable
-
implicit
val
TypeTagg: ClassTag[Type]
-
-
object
TypeTree extends reflect.internal.SymbolTable.TypeTreeExtractor with Serializable
-
implicit
val
TypeTreeTag: ClassTag[TypeTree]
-
object
TypeVar extends Serializable
-
object
Typed extends reflect.internal.SymbolTable.TypedExtractor with Serializable
-
implicit
val
TypedTag: ClassTag[Typed]
-
object
UnApply extends reflect.internal.SymbolTable.UnApplyExtractor with Serializable
-
implicit
val
UnApplyTag: ClassTag[UnApply]
-
final
val
UnitTag: Int(1)
-
-
-
object
ValDef extends reflect.internal.SymbolTable.ValDefExtractor with Serializable
-
implicit
val
ValDefTag: ClassTag[ValDef]
-
implicit
val
ValOrDefDefTag: ClassTag[ValOrDefDef]
-
object
WeakTypeTag extends Serializable
-
object
WildcardType extends reflect.internal.SymbolTable.Type with Product with Serializable
-
def
abort(msg: String): Nothing
-
def
abstractTypesToBounds(tp: Type): Type
-
def
adaptAnnotations(tree: Tree, mode: Int, pt: Type): Tree
-
-
object
adaptToNewRunMap extends reflect.internal.SymbolTable.TypeMap
-
def
adaptTypeOfReturn(tree: Tree, pt: Type, default: ⇒ Type): Type
-
def
addAnnotationChecker(checker: AnnotationChecker): Unit
-
def
addAnnotations(tree: Tree, tpe: Type): Type
-
implicit
def
addFlagOps(left: FlagSet): FlagOps
-
def
addMember(thistp: Type, tp: Type, sym: Symbol, depth: Int): Unit
-
def
addMember(thistp: Type, tp: Type, sym: Symbol): Unit
-
def
addSerializable(ps: Type*): List[Type]
-
def
addToPhasesSet(sub: SubComponent, descr: String): Unit
-
final
def
afterCurrentPhase[T](op: ⇒ T): T
-
def
afterEachPhase[T](op: ⇒ T): List[(Phase, T)]
-
final
def
afterErasure[T](op: ⇒ T): T
-
final
def
afterExplicitOuter[T](op: ⇒ T): T
-
final
def
afterFlatten[T](op: ⇒ T): T
-
final
def
afterIcode[T](op: ⇒ T): T
-
final
def
afterMixin[T](op: ⇒ T): T
-
final
def
afterPhase[T](ph: reflect.internal.Phase)(op: ⇒ T): T
-
final
def
afterPickler[T](op: ⇒ T): T
-
final
def
afterPostErasure[T](op: ⇒ T): T
-
final
def
afterRefchecks[T](op: ⇒ T): T
-
final
def
afterSpecialize[T](op: ⇒ T): T
-
final
def
afterTyper[T](op: ⇒ T): T
-
final
def
afterUncurry[T](op: ⇒ T): T
-
-
lazy val
analyzer: Analyzer { val global: DocParser.this.type }
-
-
def
annotationsConform(tp1: Type, tp2: Type): Boolean
-
def
annotationsGlb(tpe: Type, ts: List[Type]): Type
-
def
annotationsLub(tpe: Type, ts: List[Type]): Type
-
def
appliedType(tyconSym: Symbol, args: Type*): Type
-
def
appliedType(tycon: Type, args: List[Type]): Type
-
def
appliedTypeAsUpperBounds(tycon: Type, args: List[Type]): Type
-
def
arrayToRepeated(tp: Type): Type
-
def
asCompactDebugString(t: Tree): String
-
def
asCompactString(t: Tree): String
-
final
def
asInstanceOf[T0]: T0
-
def
asString(t: Tree): String
-
final
def
assert(assertion: Boolean): Unit
-
final
def
assert(assertion: Boolean, message: ⇒ Any): Unit
-
def
assertCorrectThread(): Unit
-
final
def
atPhase[T](ph: reflect.internal.Phase)(op: ⇒ T): T
-
final
def
atPhaseNotLaterThan[T](target: reflect.internal.Phase)(op: ⇒ T): T
-
final
def
atPhaseStack: List[reflect.internal.Phase]
-
def
atPhaseStackMessage: String
-
def
atPos[T <: Tree](pos: Position)(tree: T): T
-
def
backquotedPath(t: Tree): String
-
-
def
baseTypeSingletonSeq(tp: Type): BaseTypeSeq
-
final
def
beforeErasure[T](op: ⇒ T): T
-
final
def
beforeExplicitOuter[T](op: ⇒ T): T
-
final
def
beforeFlatten[T](op: ⇒ T): T
-
final
def
beforeIcode[T](op: ⇒ T): T
-
final
def
beforeMixin[T](op: ⇒ T): T
-
final
def
beforePhase[T](ph: reflect.internal.Phase)(op: ⇒ T): T
-
final
def
beforePickler[T](op: ⇒ T): T
-
final
def
beforePrevPhase[T](op: ⇒ T): T
-
final
def
beforeRefchecks[T](op: ⇒ T): T
-
final
def
beforeSpecialize[T](op: ⇒ T): T
-
final
def
beforeTyper[T](op: ⇒ T): T
-
final
def
beforeUncurry[T](op: ⇒ T): T
-
def
beginsWithTypeVarOrIsRefined(tp: Type): Boolean
-
object
binarynme
-
-
def
buildCompilerFromPhasesSet(): List[SubComponent]
-
def
canAdaptAnnotations(tree: Tree, mode: Int, pt: Type): Boolean
-
def
captureVariable(vble: Symbol): Unit
-
def
capturedVariableType(vble: Symbol, tpe: Type, erasedTypes: Boolean): Type
-
def
capturedVariableType(vble: Symbol): Type
-
-
-
var
chrs: Array[Char]
-
-
-
def
clearDocComments(): Unit
-
def
clone(): AnyRef
-
-
-
-
def
cloneSymbolsAtOwnerAndModify(syms: List[Symbol], owner: Symbol, infoFn: (Type) ⇒ Type): List[Symbol]
-
final
def
closestEnclMethod(from: Symbol): Symbol
-
-
final
def
collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) ⇒ Boolean): Map[A, B]
-
-
final
def
compareLengths(xs1: List[_], xs2: List[_]): Int
-
def
compoundBaseTypeSeq(tp: Type): BaseTypeSeq
-
def
computeInternalPhases(): Unit
-
-
def
computePlatformPhases(): Unit
-
def
computePluginPhases(): Unit
-
-
-
-
def
containsExistential(tpe: Type): Boolean
-
def
cookedDocComment(sym: Symbol, docStr: String = ""): String
-
val
cookedDocComments: HashMap[Symbol, String]
-
-
-
def
copyMethodType(tp: Type, params: List[Symbol], restpe: Type): Type
-
-
-
-
-
final
def
corresponds3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
-
def
createFromClonedSymbols[T](syms: List[Symbol], tpe: Type)(creator: (List[Symbol], Type) ⇒ T): T
-
def
createFromClonedSymbolsAtOwner[T](syms: List[Symbol], owner: Symbol, tpe: Type)(creator: (List[Symbol], Type) ⇒ T): T
-
def
createJavadoc: Boolean
-
final
def
currentPeriod: Period
-
def
currentRun: Run
-
def
currentRunId: Int
-
-
def
currentSource: SourceFile
-
-
-
def
debugStack(t: Throwable): Unit
-
def
debugString(tp: Type): String
-
final
def
debuglog(msg: ⇒ String): Unit
-
final
def
debugwarn(msg: ⇒ String): Unit
-
def
decodedSymName(tree: Tree, name: Name): String
-
def
defineBaseClassesOfCompoundType(tpe: CompoundType): Unit
-
def
defineBaseTypeSeqOfCompoundType(tpe: CompoundType): Unit
-
def
defineBaseTypeSeqOfTypeRef(tpe: TypeRef): Unit
-
def
defineParentsOfTypeRef(tpe: TypeRef): Unit
-
def
defineUnderlyingOfSingleType(tpe: SingleType): Unit
-
object
definitions extends reflect.internal.SymbolTable.DefinitionsClass
-
-
def
deriveCaseDef(cdef: Tree)(applyToBody: (Tree) ⇒ Tree): CaseDef
-
-
def
deriveDefDef(ddef: Tree)(applyToRhs: (Tree) ⇒ Tree): DefDef
-
-
def
deriveLabelDef(ldef: Tree)(applyToRhs: (Tree) ⇒ Tree): LabelDef
-
-
-
-
-
def
deriveTypeWithWildcards(syms: List[Symbol])(tpe: Type): Type
-
def
deriveValDef(vdef: Tree)(applyToRhs: (Tree) ⇒ Tree): ValDef
-
def
describeAfterEachPhase[T](op: ⇒ T): List[String]
-
def
describeAfterEveryPhase[T](op: ⇒ T): String
-
def
differentOrNone(tp1: Type, tp2: Type): Type
-
final
def
distinctBy[A, B](xs: List[A])(f: (A) ⇒ B): List[A]
-
def
doInvalidation(): Any
-
def
docComment(sym: Symbol, docStr: String, pos: Position = NoPosition): Any
-
-
-
def
docDefs(code: String): List[Parsed]
-
def
docUnit(code: String): Tree
-
object
dropRepeatedParamType extends reflect.internal.SymbolTable.TypeMap
-
object
dropSingletonType extends reflect.internal.SymbolTable.TypeMap
-
def
echoPhaseSummary(ph: Phase): Unit
-
def
elimAnonymousClass(t: Type): Type
-
def
elimRefinement(t: Type): Type
-
val
emptySymbolArray: Array[Symbol]
-
object
emptyValDef extends reflect.internal.SymbolTable.ValDef
-
val
enableTypeVarExperimentals: Boolean
-
def
encode(str: String): TermName
-
def
ensureNonOverlapping(tree: Tree, others: List[Tree], focus: Boolean): Unit
-
def
ensureNonOverlapping(tree: Tree, others: List[Tree]): Unit
-
def
ensuring(cond: (DocParser) ⇒ Boolean, msg: ⇒ Any): DocParser
-
-
def
ensuring(cond: Boolean, msg: ⇒ Any): DocParser
-
def
ensuring(cond: Boolean): DocParser
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
-
def
error(msg: String): Unit
-
val
etaExpandKeepsStar: Boolean
-
def
existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type
-
final
def
existentialTransform[T](rawSyms: List[Symbol], tp: Type, rawOwner: Option[Symbol])(creator: (List[Symbol], Type) ⇒ T): T
-
def
existentialsInType(tpe: Type): List[Symbol]
-
final
def
exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean
-
final
def
exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
-
def
expandInheritdoc(parent: String, child: String, sym: Symbol): String
-
def
expandVariables(initialStr: String, sym: Symbol, site: Symbol): String
-
def
expandWiki(str: String): String
-
def
expandedDocComment(sym: Symbol): String
-
def
expandedDocComment(sym: Symbol, site: Symbol, docStr: String = ""): String
-
def
explain[T](op: String, p: (Type, T) ⇒ Boolean, tp1: Type, arg2: T): Boolean
-
def
explainContext(c: (analyzer)#Context): String
-
def
explainTree(t: Tree): String
-
def
explainTypes(op: (Type, Type) ⇒ Any, found: Type, required: Type): Unit
-
def
explainTypes(found: Type, required: Type): Unit
-
-
-
def
fillDocComment(sym: Symbol, comment: DocComment): Unit
-
def
finalize(): Unit
-
def
findMemberFromRoot(fullName: Name): Symbol
-
final
def
findOrElse[A](xs: TraversableOnce[A])(p: (A) ⇒ Boolean)(orElse: ⇒ A): A
-
-
-
final
def
flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[B]]): List[B]
-
final
def
flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ List[C]): List[C]
-
-
final
def
flattensToEmpty(xss: Seq[Seq[_]]): Boolean
-
def
forInteractive: Boolean
-
def
forJVM: Boolean
-
def
forMSIL: Boolean
-
def
forScaladoc: Boolean
-
final
def
forall2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean
-
final
def
forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
-
final
def
foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Unit): Unit
-
final
def
foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Unit): Unit
-
final
def
foreachWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ Unit): Unit
-
def
formatted(fmtstr: String): String
-
def
freshExistentialName(suffix: String): TypeName
-
def
fromDeBruijn(owner: Symbol): TypeMap
-
object
fulltpnme extends reflect.internal.SymbolTable.TypeNames
-
-
-
-
-
-
final
def
getClass(): Class[_]
-
def
getFile(clazz: Symbol, suffix: String): File
-
def
getFile(source: AbstractFile, segments: Array[String], suffix: String): File
-
def
getSourceFile(name: String): SourceFile
-
def
getSourceFile(f: AbstractFile): BatchSourceFile
-
-
def
glbNorm(ts: List[Type], depth: Int): Type
-
def
globalError(msg: String): Unit
-
var
globalPhase: Phase
-
final
def
hasLength(xs: List[_], len: Int): Boolean
-
def
hashCode(): Int
-
-
-
-
var
ids: Int
-
final
def
ifDebug(body: ⇒ Unit): Unit
-
def
importPrivateWithinFromJavaFlags(sym: Symbol, jflags: Int): Symbol
-
-
def
inform[T](msg: String, value: T): T
-
def
inform(msg: String): Unit
-
def
informComplete(msg: String): Unit
-
def
informProgress(msg: String): Unit
-
def
informTime(msg: String, start: Long): Unit
-
def
inheritsJavaVarArgsMethod(clazz: Symbol): Boolean
-
-
-
-
def
intersectionType(tps: List[Type]): Type
-
def
intersectionType(tps: List[Type], owner: Symbol): Type
-
val
intersectionWitness: WeakHashMap[List[Type], WeakReference[Type]]
-
-
final
def
isAtPhaseAfter(p: reflect.internal.Phase): Boolean
-
def
isBoundedGeneric(tp: Type): Boolean
-
def
isCompilerUniverse: Boolean
-
def
isConstantType(tp: Type): Boolean
-
def
isDifferentType(tp1: Type, tp2: Type): Boolean
-
def
isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean
-
def
isErrorOrWildcard(tp: Type): Boolean
-
def
isHKSubType0(tp1: Type, tp2: Type, depth: Int): Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
isJavaVarargsAncestor(clazz: Symbol): Boolean
-
def
isNonRefinementClassType(tpe: Type): Boolean
-
def
isNonValueType(tp: Type): Boolean
-
def
isNumericSubType(tp1: Type, tp2: Type): Boolean
-
def
isPopulated(tp1: Type, tp2: Type): Boolean
-
def
isPossiblePrefix(clazz: Symbol): Boolean
-
def
isRaw(sym: Symbol, args: List[Type]): Boolean
-
def
isRawParameter(sym: Symbol): Boolean
-
def
isRawType(tp: Type): Boolean
-
def
isReferenceToAnyVal(t: Tree): Boolean
-
def
isReferenceToPredef(t: Tree): Boolean
-
def
isReferenceToScalaMember(t: Tree, Id: Name): Boolean
-
def
isSameType(tp1: Type, tp2: Type): Boolean
-
def
isSameType2(tp1: Type, tp2: Type): Boolean
-
def
isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean
-
def
isScriptRun: Boolean
-
def
isSingleType(tp: Type): Boolean
-
def
isSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol], depth: Int): Boolean
-
def
isSubType(tp1: Type, tp2: Type, depth: Int): Boolean
-
def
isSubType(tp1: Type, tp2: Type): Boolean
-
def
isSubTypes(tps1: List[Type], tps2: List[Type]): Boolean
-
def
isUnboundedGeneric(tp: Type): Boolean
-
def
isUseableAsTypeArg(tp: Type): Boolean
-
final
def
isUseableAsTypeArgs(tps: List[Type]): Boolean
-
final
def
isValid(period: Period): Boolean
-
final
def
isValidForBaseClasses(period: Period): Boolean
-
def
isValueType(tp: Type): Boolean
-
def
isWeakSubType(tp1: Type, tp2: Type): Boolean
-
def
isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean
-
def
itransform(transformer: DocParser.Transformer, tree: Tree): Tree
-
def
itraverse(traverser: Traverser, tree: Tree): Unit
-
-
def
kindsConform(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol): Boolean
-
-
var
lastSeenContext: (analyzer)#Context
-
var
lastSeenSourceFile: SourceFile
-
-
def
loadPlugins(): List[Plugin]
-
def
loadRoughPluginsList(): List[Plugin]
-
lazy val
loaders: SymbolLoaders { val global: DocParser.this.type }
-
final
def
log(msg: ⇒ AnyRef): Unit
-
def
logAfterEveryPhase[T](msg: String)(op: ⇒ T): Unit
-
def
logError(msg: String, t: Throwable): Unit
-
def
lookupVariable(vble: String, site: Symbol): Option[String]
-
implicit
def
lowPriorityNameOrdering[T <: Name]: Ordering[T]
-
implicit
def
lowerTermNames(n: TermName): String
-
-
def
lubDepth(ts: List[Type]): Int
-
def
makeNoSymbol: NoSymbol
-
def
manifestToTypeTag[T](mirror: Any, manifest: Manifest[T]): reflect.api.Universe.TypeTag[T]
-
final
def
map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ C): List[C]
-
def
map2Conserve[A <: AnyRef, B](xs: List[A], ys: List[B])(f: (A, B) ⇒ A): List[A]
-
final
def
map3[A, B, C, D](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ D): List[D]
-
final
def
mapFrom[A, A1 >: A, B](xs: List[A])(f: (A) ⇒ B): Map[A1, B]
-
def
mapParamss[T](sym: Symbol)(f: (Symbol) ⇒ T): List[List[T]]
-
final
def
mapWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ B): List[B]
-
final
def
matchesType(tp1: Type, tp2: Type, alwaysMatchSimple: Boolean): Boolean
-
final
val
maxTostringRecursions: Int(50)
-
def
merge(src: String, dst: String, sym: Symbol, copyFirstPara: Boolean = false): String
-
def
mergePrefixAndArgs(tps: List[Type], variance: Int, depth: Int): Option[Type]
-
final
def
mexists[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean
-
final
def
mfilter[A](xss: List[List[A]])(p: (A) ⇒ Boolean): collection.immutable.List[A]
-
final
def
mfind[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Option[A]
-
final
def
mforall[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean
-
final
def
mforeach[A](xss: List[List[A]])(f: (A) ⇒ Unit): Unit
-
def
mirrorThatLoaded(sym: Symbol): Mirror
-
-
def
missingHook(owner: Symbol, name: Name): Symbol
-
-
def
mkAttributedQualifier(tpe: Type, termSym: Symbol): Tree
-
def
mkImporter(from0: reflect.api.Universe): Importer { val from: from0.type }
-
final
def
A very minimal global customized for extracting
DocDefs. It stops right after parsing so it can readDocDefsfrom source code which would otherwise cause the compiler to go haywire.