DefinitionsClass

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

Test two objects for inequality.

final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null.

def +(other: String): String

def ->[B](y: B): (DefinitionsClass, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

Test two objects for equality.

lazy val AbsTypeTagClass: ClassSymbol

lazy val AbsTypeTagModule: ModuleSymbol

lazy val AbstractFunctionClass: Array[ClassSymbol]

lazy val AbstractPartialFunctionClass: ClassSymbol

lazy val AnnotationClass: ClassSymbol

lazy val AnnotationDefaultAttr: ClassSymbol

lazy val AnyClass: ClassSymbol

lazy val AnyRefClass: AliasTypeSymbol

lazy val AnyRefModule: ModuleSymbol

lazy val AnyValClass: ClassSymbol

lazy val Any_!=: MethodSymbol

lazy val Any_##: MethodSymbol

lazy val Any_==: MethodSymbol

lazy val Any_asInstanceOf: MethodSymbol

lazy val Any_equals: MethodSymbol

lazy val Any_getClass: MethodSymbol

lazy val Any_hashCode: MethodSymbol

lazy val Any_isInstanceOf: MethodSymbol

lazy val Any_toString: MethodSymbol

lazy val ApiUniverseClass: Symbol

def ApiUniverseReify: Symbol { ... /* 4 definitions in type refinement */ }

lazy val ArrayClass: ClassSymbol

lazy val ArrayModule: ModuleSymbol

lazy val ArrayModule_overloadedApply: TermSymbol

lazy val Array_apply: TermSymbol

lazy val Array_clone: TermSymbol

lazy val Array_length: TermSymbol

lazy val Array_update: TermSymbol

lazy val ArrowAssocClass: ClassSymbol

lazy val BaseUniverseClass: ClassSymbol

lazy val BeanGetterTargetClass: ClassSymbol

lazy val BeanPropertyAttr: ClassSymbol

lazy val BeanSetterTargetClass: ClassSymbol

lazy val BooleanBeanPropertyAttr: ClassSymbol

lazy val BooleanClass: ClassSymbol

lazy val Boolean_and: TermSymbol

lazy val Boolean_not: TermSymbol

lazy val Boolean_or: TermSymbol

lazy val BoxedBooleanClass: ClassSymbol

lazy val BoxedByteClass: ClassSymbol

lazy val BoxedCharacterClass: ClassSymbol

lazy val BoxedDoubleClass: ClassSymbol

lazy val BoxedFloatClass: ClassSymbol

lazy val BoxedIntClass: ClassSymbol

lazy val BoxedLongClass: ClassSymbol

lazy val BoxedNumberClass: ClassSymbol

lazy val BoxedShortClass: ClassSymbol

lazy val BoxedUnitClass: ClassSymbol

lazy val BoxedUnitModule: ModuleSymbol

def BoxedUnit_TYPE: TermSymbol

def BoxedUnit_UNIT: TermSymbol

lazy val BoxesRunTimeClass: Symbol

lazy val BoxesRunTimeModule: ModuleSymbol

lazy val Boxes_isNumber: Symbol

lazy val Boxes_isNumberOrBool: Symbol

lazy val BridgeClass: ClassSymbol

lazy val ByNameParamClass: ClassSymbol

lazy val ByteClass: ClassSymbol

lazy val CharClass: ClassSymbol

lazy val ClassCastExceptionClass: ClassSymbol

lazy val ClassClass: ClassSymbol

lazy val ClassTagClass: ClassSymbol

lazy val ClassTagModule: ModuleSymbol

lazy val ClassTargetClass: ClassSymbol

def ClassType(arg: Type): Type

def Class_getMethod: TermSymbol

lazy val ClassfileAnnotationClass: ClassSymbol

lazy val CloneableAttr: ClassSymbol

lazy val ComparableClass: ClassSymbol

lazy val ComparatorClass: ClassSymbol

lazy val ConsClass: ClassSymbol

lazy val ConsoleModule: ModuleSymbol

lazy val DelayedInitClass: ClassSymbol

lazy val DelegateClass: ClassSymbol

lazy val Delegate_scalaCallerTargets: HashMap[Symbol, Symbol]

var Delegate_scalaCallers: List[Symbol]

lazy val DeprecatedAttr: ClassSymbol

lazy val DeprecatedNameAttr: ClassSymbol

lazy val DoubleClass: ClassSymbol

lazy val DynamicClass: ClassSymbol

lazy val DynamicsFeature: Symbol

lazy val ElidableMethodClass: ClassSymbol

lazy val EmptyMethodCacheClass: ClassSymbol

lazy val EqualsPatternClass: ClassSymbol

lazy val ExistentialsFeature: Symbol

lazy val ExprClass: Symbol { ... /* 4 definitions in type refinement */ }

lazy val ExprModule: Symbol { ... /* 4 definitions in type refinement */ }

def ExprSplice: Symbol { ... /* 4 definitions in type refinement */ }

def ExprValue: Symbol { ... /* 4 definitions in type refinement */ }

lazy val ExprsClass: Symbol

lazy val FieldTargetClass: ClassSymbol

lazy val FloatClass: ClassSymbol

lazy val FullManifestClass: ClassSymbol

lazy val FullManifestModule: ModuleSymbol

lazy val FunctionClass: Array[ClassSymbol]

lazy val GetterTargetClass: ClassSymbol

lazy val GroupOfSpecializable: ClassSymbol

lazy val HigherKindsFeature: Symbol

lazy val ImplicitConversionsFeature: Symbol

lazy val ImplicitNotFoundClass: ClassSymbol

lazy val IndexOutOfBoundsExceptionClass: ClassSymbol

lazy val IntClass: ClassSymbol

lazy val InvocationTargetExceptionClass: ClassSymbol

lazy val IterableClass: ClassSymbol

lazy val IteratorClass: ClassSymbol

lazy val IteratorModule: ModuleSymbol

lazy val Iterator_apply: TermSymbol

lazy val JavaCloneableClass: ClassSymbol

lazy val JavaLangEnumClass: ClassSymbol

lazy val JavaLangPackage: ModuleSymbol

lazy val JavaLangPackageClass: ClassSymbol

lazy val JavaNumberClass: ClassSymbol

lazy val JavaRepeatedParamClass: ClassSymbol

lazy val JavaSerializableClass: ClassSymbol

lazy val JavaUniverseClass: Symbol

lazy val LanguageFeatureAnnot: ClassSymbol

lazy val ListClass: ClassSymbol

lazy val ListModule: ModuleSymbol

lazy val List_apply: TermSymbol

lazy val LongClass: ClassSymbol

lazy val MacroContextClass: Symbol

def MacroContextMirror: Symbol { ... /* 4 definitions in type refinement */ }

def MacroContextPrefix: Symbol { ... /* 4 definitions in type refinement */ }

def MacroContextPrefixType: Symbol { ... /* 4 definitions in type refinement */ }

def MacroContextReify: Symbol { ... /* 4 definitions in type refinement */ }

def MacroContextUniverse: Symbol { ... /* 4 definitions in type refinement */ }

lazy val MacroImplAnnotation: ClassSymbol

lazy val MacroInternalPackage: ModuleSymbol

def MacroInternal_materializeAbsTypeTag: TermSymbol

def MacroInternal_materializeClassTag: TermSymbol

def MacroInternal_materializeTypeTag: TermSymbol

lazy val MacrosFeature: Symbol

lazy val MatchErrorClass: ClassSymbol

lazy val MatchingStrategyClass: ClassSymbol

val MaxFunctionArity: Int

val MaxProductArity: Int

val MaxTupleArity: Int

lazy val MethodCacheClass: ClassSymbol

lazy val MethodClass: ClassSymbol

lazy val MethodTargetClass: ClassSymbol

lazy val MigrationAnnotationClass: ClassSymbol

lazy val MirrorOfClass: ClassSymbol

lazy val NativeAttr: ClassSymbol

lazy val NilModule: ModuleSymbol

lazy val NoManifest: ModuleSymbol

lazy val NonLocalReturnControlClass: ClassSymbol

lazy val NoneModule: ModuleSymbol

lazy val NotNullClass: ClassSymbol

object NothingClass extends BottomClassSymbol

object NullClass extends BottomClassSymbol

lazy val NullPointerExceptionClass: ClassSymbol

lazy val ObjectArray: Type

lazy val ObjectClass: ClassSymbol

lazy val ObjectRefClass: ClassSymbol

lazy val ObjectTargetClass: ClassSymbol

lazy val Object_!=: MethodSymbol

lazy val Object_##: MethodSymbol

lazy val Object_==: MethodSymbol

lazy val Object_asInstanceOf: MethodSymbol

def Object_clone: TermSymbol

lazy val Object_eq: MethodSymbol

def Object_equals: TermSymbol

def Object_finalize: TermSymbol

def Object_getClass: TermSymbol

def Object_hashCode: TermSymbol

lazy val Object_isInstanceOf: MethodSymbol

lazy val Object_ne: MethodSymbol

def Object_notify: TermSymbol

def Object_notifyAll: TermSymbol

lazy val Object_synchronized: MethodSymbol

def Object_toString: TermSymbol

lazy val OptManifestClass: ClassSymbol

lazy val OptionClass: ClassSymbol

lazy val ParamTargetClass: ClassSymbol

lazy val PartialFunctionClass: ClassSymbol

lazy val PartialManifestClass: TypeSymbol

lazy val PartialManifestModule: ModuleSymbol

lazy val PostfixOpsFeature: Symbol

lazy val PredefModule: ModuleSymbol

lazy val PredefModuleClass: Symbol

def Predef_???: TermSymbol

def Predef_classOf: TermSymbol

def Predef_conforms: TermSymbol

def Predef_identity: TermSymbol

def Predef_implicitly: TermSymbol

def Predef_wrapRefArray: TermSymbol

lazy val ProductClass: Array[ClassSymbol]

lazy val ProductRootClass: ClassSymbol

def Product_canEqual: TermSymbol

def Product_iterator: TermSymbol

def Product_productArity: TermSymbol

def Product_productElement: TermSymbol

def Product_productPrefix: TermSymbol

def ReflectBasis: TermSymbol

lazy val ReflectPackage: ModuleSymbol

def ReflectRuntimeCurrentMirror: Symbol { ... /* 4 definitions in type refinement */ }

lazy val ReflectRuntimePackage: Symbol

def ReflectRuntimeUniverse: Symbol { ... /* 4 definitions in type refinement */ }

lazy val ReflectiveCallsFeature: Symbol

lazy val RemoteAttr: ClassSymbol

lazy val RemoteExceptionClass: ClassSymbol

lazy val RemoteInterfaceClass: ClassSymbol

lazy val RepeatedParamClass: ClassSymbol

lazy val RuntimeNothingClass: ClassSymbol

lazy val RuntimeNullClass: ClassSymbol

lazy val RuntimePackage: ModuleSymbol

lazy val RuntimePackageClass: ClassSymbol

lazy val RuntimeStaticsModule: ModuleSymbol

lazy val ScalaInlineClass: ClassSymbol

lazy val ScalaLongSignatureAnnotation: ClassSymbol

lazy val ScalaNoInlineClass: ClassSymbol

lazy val ScalaNumberClass: ClassSymbol

lazy val ScalaNumericValueClasses: List[ClassSymbol]

lazy val ScalaPackage: ModuleSymbol

lazy val ScalaPackageClass: ClassSymbol

def ScalaPrimitiveValueClasses: List[ClassSymbol]

lazy val ScalaRunTimeModule: ModuleSymbol

lazy val ScalaSignatureAnnotation: ClassSymbol

lazy val ScalaStrictFPAttr: ClassSymbol

def ScalaValueClassCompanions: List[Symbol]

def ScalaValueClasses: List[ClassSymbol]

def ScalaValueClassesNoUnit: List[ClassSymbol]

lazy val SeqClass: ClassSymbol

def SeqFactory: Symbol

lazy val SeqModule: ModuleSymbol

lazy val SerialVersionUIDAttr: ClassSymbol

lazy val SerializableAttr: ClassSymbol

lazy val SerializableClass: ClassSymbol

lazy val SetterTargetClass: ClassSymbol

lazy val ShortClass: ClassSymbol

lazy val SingletonClass: ClassSymbol

lazy val SoftReferenceClass: ClassSymbol

lazy val SomeClass: ClassSymbol

lazy val SomeModule: ModuleSymbol

lazy val SpecializableModule: ModuleSymbol

Specialization.

lazy val SpecializedClass: ClassSymbol

lazy val StaticAnnotationClass: ClassSymbol

lazy val StringAddClass: ClassSymbol

lazy val StringAdd_+: TermSymbol

def StringArray: Type

lazy val StringBuilderClass: ClassSymbol

lazy val StringClass: ClassSymbol

lazy val StringModule: Symbol

lazy val String_+: MethodSymbol

lazy val SwitchClass: ClassSymbol

lazy val SymbolClass: ClassSymbol

lazy val SymbolModule: ModuleSymbol

lazy val Symbol_apply: TermSymbol

lazy val SysPackage: ModuleSymbol

def Sys_error: TermSymbol

lazy val TailrecClass: ClassSymbol

lazy val ThrowableClass: ClassSymbol

lazy val ThrowsClass: ClassSymbol

lazy val TraitSetterAnnotationClass: ClassSymbol

lazy val TransientAttr: ClassSymbol

lazy val TraversableClass: ClassSymbol

lazy val TreeCreatorClass: ClassSymbol

lazy val TupleClass: Array[Symbol]

lazy val TypeConstraintClass: ClassSymbol

lazy val TypeCreatorClass: ClassSymbol

lazy val TypeTagClass: ClassSymbol

lazy val TypeTagModule: ModuleSymbol

lazy val TypeTagsClass: ClassSymbol

lazy val UncheckedClass: ClassSymbol

lazy val UninitializedErrorClass: ClassSymbol

lazy val UnitClass: ClassSymbol

lazy val UnqualifiedModules: List[ModuleSymbol]

lazy val UnqualifiedOwners: Set[Symbol]

lazy val UnspecializedClass: ClassSymbol

lazy val ValueTypeClass: ClassSymbol

lazy val VarargsClass: ClassSymbol

lazy val VolatileAttr: ClassSymbol

lazy val VolatileObjectRefClass: ClassSymbol

lazy val WeakReferenceClass: ClassSymbol

lazy val abbrvTag: Map[Symbol, Char]

def abstractFunctionForFunctionType(tp: Type): Type

def abstractFunctionType(formals: List[Type], restpe: Type): Type

def addScalaCallerInfo(scalaCaller: Symbol, methSym: Symbol): Unit

lazy val anyparam: List[Type]

lazy val anyrefparam: List[Type]

lazy val anyvalparam: List[Type]

def arrayApplyMethod: TermSymbol

def arrayClassMethod: TermSymbol

def arrayCloneMethod: TermSymbol

def arrayElementClassMethod: TermSymbol

def arrayLengthMethod: TermSymbol

def arrayType(arg: Type): Type

def arrayUpdateMethod: TermSymbol

final def asInstanceOf[T0]: T0

Cast the receiver object to be of type T0.

def boundedClassType(upperBound: Type): Type

Given type U, creates a Type representing Class[_ <: U].

lazy val boxMethod: Map[Symbol, TermSymbol]

lazy val boxedClass: Map[Symbol, ClassSymbol]

lazy val boxedClassValues: Set[Symbol]

lazy val boxedModule: Map[Symbol, ModuleSymbol]

def briefParentsString(parents: List[Type]): String

def byNameType(arg: Type): Type

def classExistentialType(clazz: Symbol): Type

Given a class symbol C with type parameters T1, T2, .

def classesFirst(tps: List[Type]): List[Type]

Order a list of types with non-trait classes before others.

def clone(): AnyRef

Create a copy of the receiver object.

def compilerSymbolFromTag(tt: scala.reflect.base.Universe#AbsTypeTag[_]): Symbol

def compilerTypeFromTag(tt: scala.reflect.base.Universe#AbsTypeTag[_]): Type

def delayedInitMethod: TermSymbol

def elementType(container: Symbol, tp: Type): Type

var emptypackagescope: Scope

def ensureAccessibleMethod: TermSymbol

def ensuring(cond: (DefinitionsClass) ⇒ Boolean, msg: ⇒ Any): DefinitionsClass

def ensuring(cond: (DefinitionsClass) ⇒ Boolean): DefinitionsClass

def ensuring(cond: Boolean, msg: ⇒ Any): DefinitionsClass

def ensuring(cond: Boolean): DefinitionsClass

final def eq(arg0: AnyRef): Boolean

Tests whether the argument (arg0) is a reference to the receiver object (this).

def equals(arg0: Any): Boolean

The equality method for reference types.

lazy val experimentalModule: ModuleSymbol

def finalize(): Unit

Called by the garbage collector on the receiver object when there are no more references to the object.

def findNamedMember(segs: List[Name], root: Symbol): Symbol

def findNamedMember(fullName: Name, root: Symbol): Symbol

def formatted(fmtstr: String): String

Returns string formatted according to given format string.

def functionApply(n: Int): TermSymbol

def functionType(formals: List[Type], restpe: Type): Type

final def getClass(): Class[_]

A representation that corresponds to the dynamic class of the receiver object.

def getClassReturnType(tp: Type): Type

def getDecl(owner: Symbol, name: Name): Symbol

Using getDecl rather than getMember may avoid issues with OverloadedTypes turning up when you don't want them, if you know the method in question is uniquely declared in the given owner.

def getDeclIfDefined(owner: Symbol, name: Name): Symbol

def getLanguageFeature(name: String, owner: Symbol = languageFeatureModule): Symbol

def getMember(owner: Symbol, name: Name): Symbol

def getMemberClass(owner: Symbol, name: Name): ClassSymbol

def getMemberIfDefined(owner: Symbol, name: Name): Symbol

def getMemberMethod(owner: Symbol, name: Name): TermSymbol

def getMemberModule(owner: Symbol, name: Name): ModuleSymbol

def getMemberType(owner: Symbol, name: Name): TypeSymbol

def getMemberValue(owner: Symbol, name: Name): TermSymbol

def getProductArgs(tpe: Type): List[Type]

if tpe <: ProductN[T1,.

def hasJavaMainMethod(path: String): Boolean

def hasJavaMainMethod(sym: Symbol): Boolean

def hasRepeatedParam(tp: Type): Boolean

def hashCode(): Int

The hashCode method for reference types.

def init(): Unit

def isArrayOfSymbol(tp: Type, elem: Symbol): Boolean

def isArrowAssoc(sym: Symbol): Boolean

lazy val isBox: Set[Symbol]

def isBoxedValueClass(sym: Symbol): Boolean

Is symbol a boxed value class, e.

def isByNameParamType(tp: Type): Boolean

def isCastSymbol(sym: Symbol): Boolean

def isCorrespondingDelegate(delegateType: Type, functionType: Type): Boolean

def isDefinitionsInitialized: Boolean

def isExactProductType(tp: Type): Boolean

returns true if this type is exactly ProductN[T1,.

def isFunctionType(tp: Type): Boolean

def isGetClass(sym: Symbol): Boolean

final def isInstanceOf[T0]: Boolean

Test whether the dynamic type of the receiver object is T0.

def isJavaMainMethod(sym: Symbol): Boolean

def isJavaRepeatedParamType(tp: Type): Boolean

def isJavaVarArgs(params: Seq[Symbol]): Boolean

def isJavaVarArgsMethod(m: Symbol): Boolean

def isMetaAnnotation(sym: Symbol): Boolean

def isNonUnitValueClass(sym: Symbol): Boolean

def isNoneType(tp: Type): Boolean

def isNumericSubClass(sub: Symbol, sup: Symbol): Boolean

def isNumericValueClass(sym: Symbol): Boolean

Is symbol a numeric value class?

def isNumericValueType(tp: Type): Boolean

Is type's symbol a numeric value class?

def isOptionType(tp: Type): Boolean

def isPartialFunctionType(tp: Type): Boolean

lazy val isPhantomClass: Set[Symbol]

Is symbol a phantom class for which no runtime representation exists?

lazy val isPossibleSyntheticParent: Set[Symbol]

Is the symbol that of a parent which is added during parsing?

def isPossiblySpecializedType(tp: Type)(cond: (Type) ⇒ Boolean): Boolean

def isPredefMemberNamed(sym: Symbol, name: Name): Boolean

Is sym a member of Predef with the given name? Note: DON't replace this by sym == Predef_conforms/etc, as Predef_conforms is a def which does a member lookup (it can't be a lazy val because we might reload Predef during resident compilations).

def isPrimitiveArray(tp: Type): Boolean

def isPrimitiveValueClass(sym: Symbol): Boolean

Is symbol a value class?

def isPrimitiveValueType(tp: Type): Boolean

def isProductNClass(sym: Symbol): Boolean

def isReferenceArray(tp: Type): Boolean

def isRepeatedParamType(tp: Type): Boolean

def isScalaRepeatedParamType(tp: Type): Boolean

def isScalaVarArgs(params: Seq[Symbol]): Boolean

def isSeqType(tp: Type): Boolean

def isSomeType(tp: Type): Boolean

def isSpecializableClass(sym: Symbol): Boolean

def isStringAddition(sym: Symbol): Boolean

def isTupleSymbol(sym: Symbol): Boolean

def isTupleType(tp: Type): Boolean

def isTupleTypeDirect(tp: Type): Boolean

lazy val isUnbox: Set[Symbol]

def isVarArgTypes(formals: Seq[Type]): Boolean

def isVarArgsList(params: Seq[Symbol]): Boolean

def iteratorOfType(tp: Type): Type

def javaRepeatedType(arg: Type): Type

def javaTypeToValueClass(jtype: Class[_]): Symbol

lazy val languageFeatureModule: ModuleSymbol

lazy val magicSymbols: List[Symbol { ... /* 4 definitions in type refinement */ }]

lazy val metaAnnotations: Set[Symbol]

def methodCache_add: TermSymbol

def methodCache_find: TermSymbol

def methodClass_setAccessible: TermSymbol

var nbScalaCallers: Int

final def ne(arg0: AnyRef): Boolean

Equivalent to !(this eq that).

def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: (List[Symbol]) ⇒ (Option[List[Type]], Type)): MethodSymbol

def newScalaCaller(delegateType: Type): MethodSymbol

def newT1NoParamsMethod(owner: Symbol, name: TermName, flags: Long)(createFn: (Symbol) ⇒ Type): MethodSymbol

def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: (Symbol) ⇒ Type): MethodSymbol

T1 means one type parameter.

def normalizedParents(parents: List[Type]): List[Type]

The following transformations applied to a list of parents.

final def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

final def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

lazy val numericWeight: Map[Symbol, Int]

def optionType(tp: Type): Type

def packageExists(packageName: String): Boolean

def parentsString(parents: List[Type]): String

def prepend[S >: ClassSymbol](elem0: S, elems: Array[ClassSymbol])(implicit arg0: ClassTag[S]): Array[S]

def productProj(n: Int, j: Int): TermSymbol

def productProj(z: Symbol, j: Int): TermSymbol

def productType(elems: List[Type]): Type

lazy val refClass: Map[Symbol, ClassSymbol]

def removeLaterObjects(tps: List[Type]): List[Type]

Remove references to class Object (other than the head) in a list of parents

def removeRedundantObjects(tps: List[Type]): List[Type]

Remove all but one reference to class Object from a list of parents.

def scalaRepeatedType(arg: Type): Type

def scalaRuntimeSameElements: TermSymbol

def seqType(arg: Type): Type

def signature(tp: Type): String

def someType(tp: Type): Type

final def synchronized[T0](arg0: ⇒ T0): T0

def termMember(owner: Symbol, name: String): Symbol

def toString(): String

Creates a String representation of this object.

def tupleField(n: Int, j: Int): TermSymbol

def tupleType(elems: List[Type]): Type

Creators for TupleN, ProductN, FunctionN.

def typeMember(owner: Symbol, name: String): Symbol

def typeParamsString(tp: Type): String

def typeStringNoPackage(tp: Type): String

def unapplyUnwrap(tpe: Type): Type

lazy val unboxMethod: Map[Symbol, TermSymbol]

def unboxedValueClass(sym: Symbol): Symbol

If symbol is a value class (boxed or not), return the unboxed value class.

lazy val uncheckedStableClass: ClassSymbol

lazy val uncheckedVarianceClass: ClassSymbol

def unspecializedSymbol(sym: Symbol): Symbol

def valueClassToJavaType(sym: Symbol): Class[_]

def valueParamsString(tp: Type): String

def vmClassType(arg: Type): Type

def vmSignature(sym: Symbol, info: Type): String

lazy val volatileRefClass: Map[Symbol, ClassSymbol]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wrapArrayMethodName(elemtp: Type): TermName

def →[B](y: B): (DefinitionsClass, B)

val self: Any

val self: Any

val EmptyPackage: ModuleSymbol

val EmptyPackageClass: ClassSymbol

def Predef_AnyRef: ModuleSymbol

val RootClass: ClassSymbol

val RootPackage: ModuleSymbol

def getClass(fullname: Name): ClassSymbol

def getModule(fullname: Name): ModuleSymbol

def isTupleTypeOrSubtype(tp: Type): Boolean

def typeCaseType(clazz: Symbol): Type

To avoid unchecked warnings on polymorphic classes, translate a Foo[T] into a Foo[_] for use in the pattern matcher.

def x: DefinitionsClass

def x: DefinitionsClass