abstract
class
SymbolTable extends reflect.internal.SymbolTable
Instance Constructors
-
new
SymbolTable()
Abstract Value Members
-
abstract
def
currentRunId: RunId
-
abstract
def
log(msg: ⇒ AnyRef): Unit
-
abstract
def
mirrorThatLoaded(sym: Symbol): Mirror
-
abstract
def
newLazyTreeCopier: TreeCopier
-
abstract
def
newStrictTreeCopier: TreeCopier
-
abstract
val
phaseWithId: Array[reflect.internal.Phase]
-
abstract
def
picklerPhase: reflect.internal.Phase
-
abstract
val
rootMirror: Mirror
-
abstract
def
settings: MutableSettings
-
abstract
val
treeInfo: TreeInfo { val global: SymbolTable.this.type }
Concrete Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(other: String): String
-
-
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]
-
final
val
AnyDepth: Int(-3)
-
implicit
def
AnyNameOps(name: Name): NameOps[Name]
-
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
DefaultLogThreshhold: Int(50)
-
final
val
DoubleTag: Int(9)
-
object
EmptyScope extends reflect.internal.SymbolTable.Scope
-
object
EmptyTree extends reflect.internal.SymbolTable.Tree with reflect.internal.SymbolTable.TermTree with reflect.internal.SymbolTable.CannotHaveAttrs with Product with Serializable
-
-
final
val
EnumTag: Int(13)
-
object
ErasedValueType extends Serializable
-
object
ErroneousAnnotation extends reflect.internal.SymbolTable.CompleteAnnotationInfo
-
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
LookupNotFound extends reflect.internal.SymbolTable.NameLookup with Product with Serializable
-
object
Match extends reflect.internal.SymbolTable.MatchExtractor with Serializable
-
implicit
val
MatchTag: ClassTag[Match]
-
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.ModifiersExtractor 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
-
def
NewFromConstructor(constructor: Symbol, args: Tree*): Apply
-
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]
-
implicit
val
SymTreeTag: ClassTag[SymTree]
-
implicit
val
SymbolTag: ClassTag[Symbol]
-
object
Template extends reflect.internal.SymbolTable.TemplateExtractor with Serializable
-
implicit
val
TemplateTag: ClassTag[Template]
-
object
TermName extends reflect.internal.Names.TermNameExtractor
-
-
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]
-
object
TypeName extends reflect.internal.Names.TypeNameExtractor
-
-
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
-
object
abstractTypesToBounds extends reflect.internal.SymbolTable.TypeMap
-
def
adaptAnnotations(tree: Tree, mode: reflect.internal.Mode, pt: Type): Tree
-
-
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
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
arrayToRepeated(tp: Type): Type
-
final
def
asInstanceOf[T0]: T0
-
def
assertCorrectThread(): Unit
-
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
-
def
beginsWithTypeVarOrIsRefined(tp: Type): Boolean
-
object
binarynme
-
-
def
canAdaptAnnotations(tree: Tree, mode: reflect.internal.Mode, 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
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]
-
-
def
commonOwner(t: Type): Symbol
-
-
final
def
compareLengths(xs1: List[_], xs2: List[_]): Int
-
def
compoundBaseTypeSeq(tp: Type): BaseTypeSeq
-
def
computeBaseClasses(tpe: Type): List[Symbol]
-
-
def
containsExistential(tpe: Type): Boolean
-
-
-
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
-
final
def
currentPeriod: Period
-
def
debugStack(t: Throwable): Unit
-
def
debugString(tp: Type): String
-
def
debuglog(msg: ⇒ String): Unit
-
def
decodedSymName(tree: Tree, name: Name): String
-
final
def
decr(depth: Int): Int
-
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
devWarning(msg: ⇒ String): Unit
-
final
def
distinctBy[A, B](xs: List[A])(f: (A) ⇒ B): List[A]
-
object
dropIllegalStarTypes extends reflect.internal.SymbolTable.TypeMap
-
def
duplicateAndKeepPositions(tree: Tree): Tree
-
def
elimAnonymousClass(t: Type): Type
-
object
emptyValDef extends reflect.internal.SymbolTable.ValDef with reflect.internal.SymbolTable.CannotHaveAttrs
-
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: (SymbolTable) ⇒ Boolean, msg: ⇒ Any): SymbolTable
-
-
def
ensuring(cond: Boolean, msg: ⇒ Any): SymbolTable
-
def
ensuring(cond: Boolean): SymbolTable
-
final
def
enteringPhase[T](ph: reflect.internal.Phase)(op: ⇒ T): T
-
final
def
enteringPhaseNotLaterThan[T](target: reflect.internal.Phase)(op: ⇒ T): T
-
final
def
enteringPrevPhase[T](op: ⇒ T): T
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
erasure: Erasure { val global: SymbolTable.this.type }
-
def
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
-
final
def
exitingPhase[T](ph: reflect.internal.Phase)(op: ⇒ T): T
-
def
explain[T](op: String, p: (Type, T) ⇒ Boolean, tp1: Type, arg2: T): Boolean
-
def
explainTypes(op: (Type, Type) ⇒ Any, found: Type, required: Type): Unit
-
def
explainTypes(found: Type, required: Type): Unit
-
def
finalize(): Unit
-
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
-
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
-
object
fulltpnme extends reflect.internal.SymbolTable.TypeNames
-
val
gen: TreeGen { val global: SymbolTable.this.type }
-
-
final
def
getClass(): Class[_]
-
def
glb(ts: List[Type], depth: Int): Type
-
-
def
glbNorm(ts: List[Type], depth: Int): Type
-
def
globalError(msg: String): Unit
-
final
def
hasLength(xs: List[_], len: Int): Boolean
-
def
hashCode(): Int
-
var
ids: Int
-
def
importableMembers(pre: Type): Scope
-
var
indent: String
-
-
def
inform(msg: String): 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
isDummyAppliedType(tp: Type): Boolean
-
def
isErrorOrWildcard(tp: Type): Boolean
-
def
isExistentialType(tp: Type): Boolean
-
def
isHKSubType(tp1: Type, tp2: Type, depth: Int): Boolean
-
def
isImplicitMethodType(tp: Type): Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
isJavaVarargsAncestor(clazz: Symbol): Boolean
-
def
isNonRefinementClassType(tpe: Type): Boolean
-
def
isNumericSubType(tp1: Type, tp2: Type): Boolean
-
def
isPastTyper: Boolean
-
def
isPopulated(tp1: Type, tp2: Type): Boolean
-
def
isPossiblePrefix(clazz: Symbol): Boolean
-
def
isRawIfWithoutArgs(sym: Symbol): Boolean
-
def
isRawParameter(sym: Symbol): Boolean
-
def
isRawType(tp: Type): 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
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
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
isWeakSubType(tp1: Type, tp2: Type): Boolean
-
def
isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean
-
def
itransform(transformer: Transformer, tree: Tree): Tree
-
def
itraverse(traverser: Traverser, tree: Tree): Unit
-
-
def
kindsConform(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol): Boolean
-
implicit
def
lowPriorityNameOrdering[T <: Name]: Ordering[T]
-
def
lub(ts: List[Type], depth: Int): Type
-
-
def
lubDepth(ts: List[Type]): Int
-
def
lubList(ts: List[Type], depth: Int): List[Type]
-
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
-
def
matchingParams(syms1: List[Symbol], syms2: List[Symbol], syms1isJava: Boolean, syms2isJava: Boolean): Boolean
-
final
val
maxTostringRecursions: Int(50)
-
def
mergePrefixAndArgs(tps: List[Type], variance: reflect.internal.Variance, depth: Int): Option[Type]
-
final
def
mexists[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean
-
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
missingHook(owner: Symbol, name: Name): Symbol
-
def
mkImporter(from0: Universe): Importer { val from: from0.type }
-
final
def
mmap[A, B](xss: List[List[A]])(f: (A) ⇒ B): collection.immutable.List[collection.immutable.List[B]]
-
final
val
nameDebug: Boolean(false)
-
final
def
ne(arg0: AnyRef): Boolean
-
def
needsOuterTest(patType: Type, selType: Type, currentOwner: Symbol): Boolean
-
def
nestedMemberType(sym: Symbol, pre: Type, owner: Symbol): Type
-
-
def
newBaseTypeSeq(parents: List[Type], elems: Array[Type]): BaseTypeSeq
-
def
newExistentialType(quantified: List[Symbol], underlying: Type): Type
-
def
newFreeTermSymbol(name: TermName, value: ⇒ Any, flags: Long, origin: String): FreeTermSymbol
-
def
newFreeTypeSymbol(name: TypeName, flags: Long, origin: String): FreeTypeSymbol
-
def
newNestedScope(outer: Scope): Scope
-
def
newPackageScope(pkgClass: Symbol): Scope
-
def
newRawTreePrinter(writer: PrintWriter): RawTreePrinter
-
def
newScope: Scope
-
def
newScopeWith(elems: Symbol*): Scope
-
def
newTermName(bs: Array[Byte], offset: Int, len: Int): TermName
-
def
newTermName(s: String): TermName
-
def
newTermName(cs: Array[Char], offset: Int, len: Int, cachedString: String): TermName
-
def
newTermName(cs: Array[Char]): TermName
-
def
newTermName(cs: Array[Char], offset: Int, len: Int): TermName
-
def
newTermNameCached(s: String): TermName
-
-
def
newTreePrinter(stream: OutputStream): TreePrinter
-
def
newTreePrinter(writer: PrintWriter): TreePrinter
-
def
newTypeName(bs: Array[Byte], offset: Int, len: Int): TypeName
-
def
newTypeName(cs: Array[Char], offset: Int, len: Int): TypeName
-
def
newTypeName(s: String): TypeName
-
def
newTypeName(cs: Array[Char], offset: Int, len: Int, cachedString: String): TypeName
-
def
newTypeName(cs: Array[Char]): TypeName
-
def
newTypeNameCached(s: String): TypeName
-
def
newUndoLog: UndoLog
-
def
nextId(): Int
-
object
nme extends reflect.internal.SymbolTable.TermNames
-
def
nonTrivialMembers(clazz: Symbol): Scope
-
def
normalizePlus(tp: Type): Type
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
-
def
objToAny(tp: Type): Type
-
def
openPackageModule(pkgClass: Symbol): Unit
-
def
openPackageModule(container: Symbol, dest: Symbol): Unit
-
def
originalEnclosingMethod(sym: Symbol): Symbol
-
val
originalOwner: HashMap[Symbol, Symbol]
-
def
overloadedType(pre: Type, alternatives: List[Symbol]): Type
-
final
def
packSymbols(hidden: List[Symbol], tp: Type, rawOwner: Option[Symbol]): Type
-
def
paramString(tp: Type): String
-
object
pendingSuperCall extends reflect.internal.SymbolTable.Apply with reflect.internal.SymbolTable.CannotHaveAttrs
-
object
perRunCaches
-
final
def
period(rid: RunId, pid: Int): Period
-
var
phStack: List[reflect.internal.Phase]
-
final
def
phase: reflect.internal.Phase
-
final
def
phaseId(period: Period): Int
-
final
def
phaseOf(period: Period): reflect.internal.Phase
-
final
def
phase_=(p: reflect.internal.Phase): Unit
-
final
def
popPhase(ph: reflect.internal.Phase): Unit
-
-
def
propagatePackageBoundary(jflags: JavaAccFlags, syms: Symbol*): Unit
-
def
propagatePackageBoundary(m: Member, syms: Symbol*): Unit
-
def
propagatePackageBoundary(c: Class[_], syms: Symbol*): Unit
-
final
def
pushPhase(ph: reflect.internal.Phase): reflect.internal.Phase
-
def
quotedName(name: String): String
-
def
quotedName(name: Name): String
-
def
quotedName(name: Name, decode: Boolean): String
-
def
rangePos(source: SourceFile, start: Int, point: Int, end: Int): Position
-
def
rawToExistential: TypeMap
-
def
refChecks: RefChecks { val global: SymbolTable.this.type }
-
def
referenceCapturedVariable(vble: Symbol): Tree
-
def
refinedType(parents: List[Type], owner: Symbol): Type
-
-
def
reify[T](expr: T): Expr[T]
-
def
removeAllAnnotationCheckers(): Unit
-
def
render(what: Any, mkPrinter: (PrintWriter) ⇒ SymbolTable.TreePrinter, printTypes: BooleanFlag, printIds: BooleanFlag, printKinds: BooleanFlag, printMirrors: BooleanFlag, printPositions: BooleanFlag): String
-
def
repackExistential(tp: Type): Type
-
final
def
runId(period: Period): RunId
-
final
def
sameLength(xs1: List[_], xs2: List[_]): Boolean
-
def
sameWeakLubAsLub(tps: List[Type]): Boolean
-
def
saveOriginalOwner(sym: Symbol): Unit
-
def
scopeTransform(owner: Symbol)(op: ⇒ Scope): Scope
-
def
setPackageAccessBoundary(sym: Symbol): Symbol
-
val
shorthands: Set[String]
-
def
shouldLogAtThisPhase: Boolean
-
def
shouldTriggerCompleter(symbol: Symbol, completer: Type, isFlagRelated: Boolean, mask: Long): Boolean
-
def
show(flags: FlagSet): String
-
def
show(name: Name): String
-
-
final
val
showOuterTests: Boolean(false)
-
def
showRaw(flags: FlagSet): String
-
def
showRaw(name: Name): String
-
-
def
singleType(pre: Type, sym: Symbol): Type
-
-
def
skipPrefixOf(pre: Type, clazz: Symbol): Boolean
-
var
skolemizationLevel: Int
-
-
def
solidDescendants(tree: Tree): List[Tree]
-
def
solve(tvars: List[TypeVar], tparams: List[Symbol], variances: List[reflect.internal.Variance], upper: Boolean, depth: Int): Boolean
-
def
solve(tvars: List[TypeVar], tparams: List[Symbol], variances: List[reflect.internal.Variance], upper: Boolean): Boolean
-
-
def
specializesSym(tp1: Type, sym1: Symbol, tp2: Type, sym2: Symbol, depth: Int): Boolean
-
def
specializesSym(tp: Type, sym: Symbol, depth: Int): Boolean
-
implicit
def
stringToTermName(s: String): TermName
-
implicit
def
stringToTypeName(s: String): TypeName
-
def
supplementErrorMessage(msg: String): String
-
final
def
suspendingTypeVars[T](tvs: List[TypeVar])(op: ⇒ T): T
-
def
symName(tree: Tree, name: Name): String
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
throwableAsString(t: Throwable): String
-
def
toString(): String
-
object
tpnme extends reflect.internal.SymbolTable.TypeNames
-
final
val
traceSymbolActivity: Boolean
-
object
traceSymbols extends TraceSymbolActivity
-
def
transformedType(tpe: Type): Type forSome {val _75: Erasure { val global: SymbolTable.this.type }}
-
def
transformedType(sym: Symbol): Type forSome {val _87: Erasure { val global: SymbolTable.this.type }}
-
final
def
transposeSafe[A](ass: List[List[A]]): Option[List[List[A]]]
-
lazy val
treeBuild: TreeGen { val global: SymbolTable.this.type }
-
-
def
treeLine(t: Tree): String
-
val
treeNodeCount: View
-
def
treeStatus(t: Tree, enclosingTree: Tree): String
-
def
treeSymStatus(t: Tree): String
-
def
treeToString(tree: Tree): String
-
def
typeArgsString(tp: Type): String
-
def
typeConstructorLubList(ts: List[Type]): List[Type]
-
object
typeDebug
-
def
typeDepth(tp: Type): Int
-
-
-
def
typeOf[T](implicit ttag: TypeTag[T]): Type
-
def
typeParamsString(tp: Type): String
-
def
typeParamsToExistentials(clazz: Symbol): List[Symbol]
-
def
typeParamsToExistentials(clazz: Symbol, tparams: List[Symbol]): List[Symbol]
-
-
def
typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]
-
