Showing content from https://www.scala-lang.org/api/2.11.12/scala-compiler/scala/tools/nsc/symtab/SymbolTable.html below:
SymbolTable - Scala Compiler 2.11.12
final def !=(arg0: Any): Boolean
final def ##(): Int
def +(other: String): String
def ->[B](y: B): (SymbolTable, B)
final def ==(arg0: Any): Boolean
val AllOps: SymbolOps
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]
implicit def AnyNameOps(name: Name): NameOps[Name]
object AppliedTypeTree extends reflect.internal.SymbolTable.AppliedTypeTreeExtractor with Serializable
implicit val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]
def Apply(sym: Symbol, args: Tree*): Tree
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
val ArrayArgument: ArrayAnnotArg.type
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 reflect.internal.SymbolTable.PlainAttachment with Product with Serializable
def Bind(sym: Symbol, body: Tree): Bind
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)
def CaseDef(pat: Tree, body: Tree): CaseDef
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)
object CompoundType
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)
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
lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter
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
def FlagOps(mask: Long): SymbolOps
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(sym: Symbol): Ident
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]
def JavaMethodType(params: List[Symbol], resultType: Type): JavaMethodType
object Kind
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
val LiteralArgument: LiteralAnnotArg.type
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): Modifiers
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
val NestedArgument: NestedAnnotArg.type
implicit val NestedArgumentTag: ClassTag[NestedAnnotArg]
def New(sym: Symbol, args: Tree*): Tree
def New(tpe: Type, argss: List[List[Tree]]): Tree
def New(tpe: Type, args: Tree*): Tree
def New(tpt: Tree, argss: List[List[Tree]]): Tree
object New extends reflect.internal.SymbolTable.NewExtractor with Serializable
def NewFromConstructor(constructor: Symbol, args: Tree*): Apply
implicit val NewTag: ClassTag[New]
val NoFlags: FlagSet
val NoKindErrors: KindErrors
lazy val NoMods: Modifiers
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]
object RefTree extends reflect.internal.SymbolTable.RefTreeExtractor
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, sym: Symbol): Select
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]
object StaticallyAnnotatedType
implicit val StringContextStripMarginOps: (StringContext) â StringContextStripMarginOps
final val StringTag: Int(10)
def Super(sym: Symbol, mix: TypeName): Tree
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]
def Template(sym: Symbol, body: List[Tree]): Template
object Template extends reflect.internal.SymbolTable.TemplateExtractor with Serializable
implicit val TemplateTag: ClassTag[Template]
object TermName extends reflect.internal.Names.TermNameExtractor
implicit def TermNameOps(name: TermName): NameOps[TermName]
implicit val TermNameTag: ClassTag[TermName]
implicit val TermSymbolTag: ClassTag[TermSymbol]
implicit val TermTreeTag: ClassTag[TermTree]
def This(sym: Symbol): Tree
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]
def TypeBoundsTree(sym: Symbol): TypeBoundsTree
def TypeBoundsTree(bounds: TypeBounds): TypeBoundsTree
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 def TypeNameOps(name: TypeName): NameOps[TypeName]
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]
def TypeTree(tp: Type): TypeTree
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]
object ValOrDefDef
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 adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds]
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: Depth): Unit
def addMember(thistp: Type, tp: Type, sym: Symbol): Unit
def addSerializable(ps: Type*): List[Type]
def annotatedType(annots: List[AnnotationInfo], underlying: Type): Type
def annotationToTree(ann: Annotation): Tree
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(tyconSym: Symbol, args: List[Type]): Type
def appliedType(tycon: Type, 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 baseTypeOfNonClassTypeRef(tpe: NonClassTypeRef, clazz: Symbol): Type
def baseTypeSingletonSeq(tp: Type): BaseTypeSeq
def basetypeRecursions: Int
def basetypeRecursions_=(value: Int): Unit
object binarynme
val build: ReificationSupportImpl
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
def checkKindBounds0(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol, explainErrors: Boolean): List[(Type, Symbol, KindErrors)]
var chrs: Array[Char]
def clone(): AnyRef
def cloneSymbols(syms: List[Symbol]): List[Symbol]
def cloneSymbolsAndModify(syms: List[Symbol], infoFn: (Type) â Type): List[Symbol]
def cloneSymbolsAtOwner(syms: List[Symbol], owner: Symbol): List[Symbol]
def cloneSymbolsAtOwnerAndModify(syms: List[Symbol], owner: Symbol, infoFn: (Type) â Type): List[Symbol]
final def closestEnclMethod(from: Symbol): Symbol
final def collectFirst[A, B](as: List[A])(pf: PartialFunction[A, B]): Option[B]
final def collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) â Boolean): Map[A, B]
def commonOwner(tps: List[Type]): Symbol
def commonOwner(t: Type): Symbol
def commonOwnerMap: CommonOwnerMap
final def compareLengths(xs1: List[_], xs2: List[_]): Int
lazy val compat: Compat
def compoundBaseTypeSeq(tp: Type): BaseTypeSeq
def computeBaseClasses(tpe: Type): List[Symbol]
def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol
def containsExistential(tpe: Type): Boolean
def copyClassDef(tree: Tree)(mods: Modifiers, name: Name, tparams: List[TypeDef], impl: Template): ClassDef
def copyDefDef(tree: Tree)(mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef
def copyMethodType(tp: Type, params: List[Symbol], restpe: Type): Type
def copyModuleDef(tree: Tree)(mods: Modifiers, name: Name, impl: Template): ModuleDef
def copyRefinedType(original: RefinedType, parents: List[Type], decls: Scope): Type
def copyTypeDef(tree: Tree)(mods: Modifiers, name: Name, tparams: List[TypeDef], rhs: Tree): TypeDef
def copyTypeRef(tp: Type, pre: Type, sym: Symbol, args: List[Type]): Type
def copyValDef(tree: Tree)(mods: Modifiers, name: Name, tpt: Tree, rhs: Tree): ValDef
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
def defineBaseClassesOfCompoundType(tpe: CompoundType): Unit
def defineBaseTypeSeqOfCompoundType(tpe: CompoundType): Unit
def defineBaseTypeSeqOfTypeRef(tpe: TypeRef): Unit
def defineOriginalOwner(sym: Symbol, owner: Symbol): 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 deriveClassDef(cdef: Tree)(applyToImpl: (Template) â Template): ClassDef
def deriveDefDef(ddef: Tree)(applyToRhs: (Tree) â Tree): DefDef
def deriveFreshSkolems(tparams: List[Symbol]): List[Symbol]
def deriveFunction(func: Tree)(applyToRhs: (Tree) â Tree): Function
def deriveLabelDef(ldef: Tree)(applyToRhs: (Tree) â Tree): LabelDef
def deriveModuleDef(mdef: Tree)(applyToImpl: (Template) â Template): ModuleDef
def deriveSymbols(syms: List[Symbol], symFn: (Symbol) â Symbol): List[Symbol]
def deriveSymbols2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) â Symbol): List[Symbol]
def deriveTemplate(templ: Tree)(applyToBody: (List[Tree]) â List[Tree]): Template
def deriveType(syms: List[Symbol], symFn: (Symbol) â Symbol)(tpe: Type): Type
def deriveType2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) â Symbol)(tpe: Type): Type
def deriveTypeWithWildcards(syms: List[Symbol])(tpe: Type): Type
def deriveValDef(vdef: Tree)(applyToRhs: (Tree) â Tree): ValDef
def devWarning(msg: â String): Unit
final def devWarningDumpStack(msg: â String, maxFrames: Int): 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 elapsedMessage(msg: String, start: Long): String
def elementExtract(container: Symbol, tp: Type): Type
def elementExtractOption(container: Symbol, tp: Type): Option[Type]
def elementTest(container: Symbol, tp: Type)(f: (Type) â Boolean): Boolean
def elementTransform(container: Symbol, tp: Type)(f: (Type) â Type): Type
def elimAnonymousClass(t: Type): Type
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: (SymbolTable) â Boolean): 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 enteringPhaseWithName[T](phaseName: String)(body: â 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: Symbol)(creator: (List[Symbol], Type) â T): T
def existentialsInType(tpe: Type): List[Symbol]
def existingSymbols(syms: List[Symbol]): 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
def findOverlapping(cts: List[Tree]): List[(Tree, Tree)]
final def findPhaseWithName(phaseName: String): reflect.internal.Phase
def findRecursiveBounds(ts: List[Type]): List[(Symbol, Symbol)]
final def findSymbol(xs: TraversableOnce[Symbol])(p: (Symbol) â Boolean): Symbol
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
def freshTermName(prefix: String)(implicit creator: FreshNameCreator): TermName
def freshTypeName(prefix: String)(implicit creator: FreshNameCreator): TypeName
object fulltpnme extends reflect.internal.SymbolTable.TypeNames
val gen: reflect.internal.TreeGen { val global: SymbolTable.this.type }
def genPolyType(params: List[Symbol], tpe: Type): Type
final def getClass(): Class[_]
def glb(ts: List[Type], depth: Depth): Type
def glb(ts: List[Type]): Type
def glbNorm(ts: List[Type], depth: Depth): Type
def glbResults: HashMap[(Depth, List[Type]), Type]
def globalError(pos: Position, msg: String): Unit
def globalError(msg: String): Unit
val globalFreshNameCreator: FreshNameCreator
final def hasLength(xs: List[_], len: Int): Boolean
def hashCode(): Int
var ids: Int
def importableMembers(pre: Type): Scope
def indent: String
def indent_=(value: String): Unit
var infoTransformers: InfoTransformer
def inform(pos: Position, msg: String): Unit
def inform(msg: String): Unit
def informProgress(msg: String): Unit
def informTime(msg: String, start: Long): Unit
def inheritsJavaVarArgsMethod(clazz: Symbol): Boolean
def instantiatedBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): List[TypeBounds]
lazy val internal: Internal
def intersectionType(tps: List[Type]): Type
def intersectionType(tps: List[Type], owner: Symbol): Type
def 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 isDeveloper: Boolean
def isDifferentType(tp1: Type, tp2: Type): Boolean
def isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean
def isDummyAppliedType(tp: Type): Boolean
def isEligibleForPrefixUnification(tp: Type): Boolean
def isErrorOrWildcard(tp: Type): Boolean
def isExistentialType(tp: Type): Boolean
def isHKSubType(tp1: Type, tp2: Type, depth: Depth): 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: Depth): Boolean
def isSubType(tp1: Type, tp2: Type, depth: Depth): Boolean
def isTreeSymbolPickled(tree: Tree): Boolean
def isTreeSymbolPickled(code: Int): 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
val javanme: JavaKeywords
def kindsConform(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol): Boolean
final def linkedMapFrom[A, A1 >: A, B](xs: List[A])(f: (A) â B): LinkedHashMap[A1, B]
final def lookupTypeName(cs: Array[Char]): TypeName
implicit def lowPriorityNameOrdering[T <: Name]: Ordering[T]
def lub(ts: List[Type], depth: Depth): Type
def lub(ts: List[Type]): Type
def lubDepth(ts: List[Type]): Depth
def lubList(ts: List[Type], depth: Depth): List[Type]
def lubResults: HashMap[(Depth, List[Type]), Type]
def makeNoSymbol: NoSymbol
final def map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) â C): List[C]
final 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]
final def mapList[A, B](as: List[A])(f: (A) â B): List[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]
def markAllCompleted(syms: Symbol*): Unit
def markFlagsCompleted(syms: Symbol*)(mask: Long): Unit
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: Depth): 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: Traversable[Traversable[A]])(f: (A) â Unit): Unit
final def mforeach[A](xss: List[List[A]])(f: (A) â Unit): Unit
val missingAliasException: MissingAliasControl
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 newAsSeenFromMap(pre: Type, clazz: Symbol): AsSeenFromMap
def newBaseTypeSeq(parents: List[Type], elems: Array[Type]): BaseTypeSeq
def newCodePrinter(writer: PrintWriter, tree: Tree, printRootPkg: Boolean): TreePrinter
def newDefDef(sym: Symbol, rhs: Tree)(mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree): DefDef
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
final def newNestedScope(outer: Scope): Scope
def newPackageScope(pkgClass: Symbol): Scope
def newRawTreePrinter(writer: PrintWriter): RawTreePrinter
def newScope: Scope
def newScopeWith(elems: Symbol*): Scope
def newStubSymbol(owner: Symbol, name: Name, missingMessage: String, isPackage: Boolean): Symbol
final def newTermName(bs: Array[Byte], offset: Int, len: Int): TermName
def newTermName(s: String): TermName
final def newTermName(cs: Array[Char], offset: Int, len0: Int, cachedString: String): TermName
final def newTermName(cs: Array[Char]): TermName
final def newTermName(cs: Array[Char], offset: Int, len: Int): TermName
final def newTermNameCached(s: String): TermName
def newTreePrinter(): TreePrinter
def newTreePrinter(stream: OutputStream): TreePrinter
def newTreePrinter(writer: PrintWriter): TreePrinter
def newTypeDef(sym: Symbol, rhs: Tree)(mods: Modifiers, name: TypeName, tparams: List[TypeDef]): TypeDef
final def newTypeName(bs: Array[Byte], offset: Int, len: Int): TypeName
final def newTypeName(cs: Array[Char], offset: Int, len: Int): TypeName
def newTypeName(s: String): TypeName
final def newTypeName(cs: Array[Char], offset: Int, len: Int, cachedString: String): TypeName
final def newTypeName(cs: Array[Char]): TypeName
final def newTypeNameCached(s: String): TypeName
def newValDef(sym: Symbol, rhs: Tree)(mods: Modifiers, name: TermName, tpt: Tree): ValDef
def nextExistentialId(): Int
def nextId(): Int
object nme extends reflect.internal.SymbolTable.TermNames
object noPrint extends (reflect.internal.SymbolTable.Tree) â Boolean
object noSelfType extends reflect.internal.SymbolTable.ValDef with reflect.internal.SymbolTable.CannotHaveAttrs
def nonTrivialMembers(clazz: Symbol): Scope
def normalizePlus(tp: Type): Type
final def notify(): Unit
final def notifyAll(): Unit
def numericLub(ts: List[Type]): Type
def objToAny(tp: Type): Type
def openPackageModule(pkgClass: Symbol): Unit
def openPackageModule(container: Symbol, dest: Symbol): Unit
def overloadedType(pre: Type, alternatives: List[Symbol]): Type
final def packSymbols(hidden: List[Symbol], tp: Type, rawOwner: Symbol): Type
def paramString(tp: Type): String
def pendingBaseTypes: HashSet[Type]
def pendingSubTypes: HashSet[SubTypePair]
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
def picklerSubTag(tree: Tree): Int
def picklerTag(tpe: Type): Int
def picklerTag(sym: Symbol): Int
def picklerTag(ref: AnyRef): Int
final def popPhase(ph: reflect.internal.Phase): Unit
lazy val posAssigner: PosAssigner
def postErasure: PostErasure { val global: SymbolTable.this.type }
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 recursionTable: Map[Symbol, Int]
def recursionTable_=(value: Map[Symbol, Int]): Unit
def refChecks: RefChecks { val global: SymbolTable.this.type }
def referenceCapturedVariable(vble: Symbol): Tree
def refinedType(parents: List[Type], owner: Symbol): Type
def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type
macro def reify[T](expr: T): Expr[T]
def removeAllAnnotationCheckers(): Unit
def render(what: Any, mkPrinter: (PrintWriter) â SymbolTable.TreePrinter, printTypes: BooleanFlag, printIds: BooleanFlag, printOwners: 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
final def sequence[A](as: List[Option[A]]): Option[List[A]]
def setPackageAccessBoundary(sym: Symbol): Symbol
val shorthands: Set[String]
def shouldLogAtThisPhase: Boolean
def show(position: Position): String
def show(flags: FlagSet): String
def show(name: Name): String
def show(any: Any, printTypes: BooleanFlag, printIds: BooleanFlag, printOwners: BooleanFlag, printKinds: BooleanFlag, printMirrors: BooleanFlag, printPositions: BooleanFlag): String
def showCode(tree: Tree, printTypes: BooleanFlag, printIds: BooleanFlag, printOwners: BooleanFlag, printPositions: BooleanFlag, printRootPkg: Boolean): String
def showDecl(sym: Symbol): String
def showRaw(position: Position): String
def showRaw(flags: FlagSet): String
def showRaw(name: Name): String
def showRaw(any: Any, printTypes: BooleanFlag, printIds: BooleanFlag, printOwners: BooleanFlag, printKinds: BooleanFlag, printMirrors: BooleanFlag, printPositions: BooleanFlag): String
def singleType(pre: Type, sym: Symbol): Type
def singletonBounds(hi: Type): TypeBounds
def skipPrefixOf(pre: Type, clazz: Symbol): Boolean
def skolemizationLevel: Int
def skolemizationLevel_=(value: Int): Unit
def slowButSafeEnteringPhase[T](ph: reflect.internal.Phase)(op: â T): T
def slowButSafeEnteringPhaseNotLaterThan[T](target: reflect.internal.Phase)(op: â T): T
lazy val sn: SymbolNames
def solidDescendants(tree: Tree): List[Tree]
def solve(tvars: List[TypeVar], tparams: List[Symbol], variances: List[reflect.internal.Variance], upper: Boolean, depth: Depth): Boolean
def spanningTypes(ts: List[Type]): List[Type]
def specializesSym(preLo: Type, symLo: Symbol, preHi: Type, symHi: Symbol, depth: Depth): Boolean
def specializesSym(tp: Type, sym: Symbol, depth: Depth): Boolean
def subsametypeRecursions: Int
def subsametypeRecursions_=(value: Int): Unit
def supplementErrorMessage(errorMessage: String): String
def supplementTyperState(errorMessage: String): String
final def suspendingTypeVars[T](tvs: List[TypeVar])(op: â T): T
def symName(tree: Tree, name: Name): String
def symbolOf[T](implicit arg0: WeakTypeTag[T]): TypeSymbol
def synchronizeNames: Boolean
final def synchronized[T0](arg0: â T0): T0
lazy val termNames: nme.type
def throwableAsString(t: Throwable, maxFrames: Int): String
def throwableAsString(t: Throwable): String
def toString(): String
def toStringRecursions: Int
def toStringRecursions_=(value: Int): Unit
def toStringSubjects: HashSet[Type]
object tpnme extends reflect.internal.SymbolTable.TypeNames
final val traceSymbolActivity: Boolean
object traceSymbols extends TraceSymbolActivity
def transformedType(tpe: Type): Type forSome {val _63: PostErasure { val global: SymbolTable.this.type }}
def transformedType(sym: Symbol): Type forSome {val _93: PostErasure { val global: SymbolTable.this.type }}
def transparentShallowTransform(container: Symbol, tp: Type)(f: (Type) â Type): Type
final def transposeSafe[A](ass: List[List[A]]): Option[List[List[A]]]
lazy val treeBuild: TreeGen
val treeCopy: TreeCopier
def treeLine(t: Tree): String
val treeNodeCount: View
def treeStatus(t: Tree, enclosingTree: Tree): String
def treeSymStatus(t: Tree): String
def treeToAnnotation(tree: Tree): Annotation
def treeToString(tree: Tree): String
object typeDebug
def typeDepth(tp: Type): Depth
def typeFun(tps: List[Symbol], body: Type): Type
def typeFunAnon(tps: List[Symbol], body: Type): Type
lazy val typeNames: tpnme.type
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 typeRef(pre: Type, sym: Symbol, args: List[Type]): Type
def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]
def typeToString(tpe: Type): String
def typeTreeSymbol(tree: TypeTree): Symbol
def typeVarsInType(tp: Type): List[TypeVar]
final def uncheckedBounds(tp: Type): Type
def uncurry: UnCurry { val global: SymbolTable.this.type }
val undetBaseTypeSeq: BaseTypeSeq
def undoLog: UndoLog
def unique[T <: Type](tp: T): T
object unwrapToClass extends reflect.internal.SymbolTable.ClassUnwrapper
object unwrapToStableClass extends reflect.internal.SymbolTable.ClassUnwrapper
object unwrapWrapperTypes extends reflect.internal.SymbolTable.TypeUnwrapper
def useOffsetPositions: Boolean
def validateClassInfo(tp: ClassInfoType): Unit
def validatePositions(tree: Tree): Unit
def varianceInType(tp: Type)(tparam: Symbol): reflect.internal.Variance
def varianceInTypes(tps: List[Type])(tparam: Symbol): reflect.internal.Variance
final def wait(): Unit
final def wait(arg0: Long, arg1: Int): Unit
final def wait(arg0: Long): Unit
def warning(pos: Position, msg: String): Unit
def warning(msg: String): Unit
def weakLub(tps: List[Type]): Type
def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type
def weakTypeTag[T](implicit attag: WeakTypeTag[T]): WeakTypeTag[T]
object wildcardExtrapolation extends reflect.internal.SymbolTable.TypeMap
def withTypesExplained[A](op: â A): A
def wrappingIntoTerm(tree0: Tree)(op: (Tree) â Tree): Tree
def wrappingPos(trees: List[Tree]): Position
def wrappingPos(default: Position, trees: List[Tree], focus: Boolean): Position
def wrappingPos(default: Position, trees: List[Tree]): Position
def xprintTree(treePrinter: TreePrinter, tree: Tree): Unit
def xtransform(transformer: Transformer, tree: Tree): Tree
def xtraverse(traverser: Traverser, tree: Tree): Unit
def â[B](y: B): (SymbolTable, B)
RetroSearch is an open source project built by @garambo
| Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4