definitions

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

lazy val AbstractFunctionClass: Array[Symbol]

lazy val AbstractPartialFunctionClass: ClassSymbol

lazy val AnnotationClass: ClassSymbol

lazy val AnnotationDefaultAttr: Symbol

lazy val AnyClass: ClassSymbol

lazy val AnyRefClass: AliasTypeSymbol

lazy val AnyRefModule: Symbol

lazy val AnyValClass: ClassSymbol

lazy val AnyVal_getClass: MethodSymbol

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 ArrayClass: ClassSymbol

lazy val ArrayModule: ModuleSymbol

lazy val ArrayModule_overloadedApply: Symbol

lazy val ArrayTagClass: ClassSymbol

def ArrayTagNewArray: MethodSymbol

def ArrayTagWrap: MethodSymbol

lazy val Array_apply: Symbol

lazy val Array_clone: Symbol

lazy val Array_length: Symbol

lazy val Array_update: Symbol

lazy val ArrowAssocClass: 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: Symbol

lazy val Boolean_not: Symbol

lazy val Boolean_or: Symbol

lazy val BoxedBooleanClass: Symbol

lazy val BoxedByteClass: ClassSymbol

lazy val BoxedCharacterClass: Symbol

lazy val BoxedDoubleClass: ClassSymbol

lazy val BoxedFloatClass: ClassSymbol

lazy val BoxedIntClass: ClassSymbol

lazy val BoxedLongClass: ClassSymbol

lazy val BoxedNumberClass: Symbol

lazy val BoxedShortClass: ClassSymbol

lazy val BoxedUnitClass: ClassSymbol

lazy val BoxedUnitModule: ModuleSymbol

def BoxedUnit_TYPE: Symbol

def BoxedUnit_UNIT: Symbol

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

def ClassTagTpe: MethodSymbol

lazy val ClassTargetClass: ClassSymbol

def ClassType(arg: Type): Type

def Class_getMethod: Symbol

lazy val ClassfileAnnotationClass: ClassSymbol

lazy val CloneableAttr: ClassSymbol

lazy val ComparableClass: ClassSymbol

lazy val ComparatorClass: ClassSymbol

lazy val ConcreteTypeTagClass: ClassSymbol

lazy val ConcreteTypeTagModule: ModuleSymbol

lazy val ConsClass: ClassSymbol

lazy val ConsoleModule: Symbol

lazy val DelayedInitClass: ClassSymbol

lazy val DelegateClass: Symbol

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

object EmptyPackage extends PackageSymbol with WellKnownSymbol

object EmptyPackageClass extends PackageClassSymbol with WellKnownSymbol

lazy val EqualsPatternClass: ClassSymbol

lazy val ErasureTagClass: ClassSymbol

def ErasureTagErasure: MethodSymbol

lazy val ExistentialsFeature: Symbol

lazy val ExprClass: Symbol

def ExprEval: Symbol

lazy val ExprModule: Symbol

def ExprTpe: Symbol

def ExprTree: Symbol

def ExprValue: Symbol

lazy val FieldTargetClass: ClassSymbol

lazy val FloatClass: ClassSymbol

lazy val FullManifestClass: ClassSymbol

lazy val FullManifestModule: ModuleSymbol

lazy val FunctionClass: Array[Symbol]

lazy val GetterTargetClass: ClassSymbol

lazy val GroupOfSpecializable: Symbol

lazy val HigherKindsFeature: Symbol

lazy val ImplicitConversionsFeature: Symbol

lazy val ImplicitNotFoundClass: ClassSymbol

lazy val IndexOutOfBoundsExceptionClass: Symbol

lazy val IntClass: ClassSymbol

lazy val InvocationTargetExceptionClass: Symbol

lazy val IterableClass: ClassSymbol

lazy val IteratorClass: ClassSymbol

lazy val IteratorModule: ModuleSymbol

lazy val Iterator_apply: Symbol

lazy val JavaCloneableClass: ClassSymbol

lazy val JavaLangEnumClass: ClassSymbol

lazy val JavaLangPackage: PackageSymbol

lazy val JavaLangPackageClass: Symbol

lazy val JavaRepeatedParamClass: ClassSymbol

lazy val JavaSerializableClass: Symbol

lazy val LanguageFeatureAnnot: ClassSymbol

lazy val ListClass: ClassSymbol

lazy val ListModule: ModuleSymbol

lazy val List_apply: Symbol

lazy val LongClass: ClassSymbol

lazy val MacroContextClass: ClassSymbol

def MacroContextMirror: Symbol

def MacroContextPrefix: Symbol

def MacroContextPrefixType: Symbol

def MacroContextReify: Symbol

lazy val MacroImplAnnotation: ClassSymbol

lazy val MacroInternalPackage: Symbol

def MacroInternal_materializeArrayTag: MethodSymbol

def MacroInternal_materializeClassTag: MethodSymbol

def MacroInternal_materializeConcreteTypeTag: MethodSymbol

def MacroInternal_materializeErasureTag: MethodSymbol

def MacroInternal_materializeTypeTag: MethodSymbol

lazy val MacrosFeature: Symbol

lazy val MarkerCPSTypes: 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: Symbol

lazy val MethodTargetClass: ClassSymbol

lazy val MigrationAnnotationClass: ClassSymbol

lazy val NativeAttr: ClassSymbol

lazy val NilModule: ModuleSymbol

lazy val NoManifest: ModuleSymbol

lazy val NonLocalReturnControlClass: ClassSymbol

lazy val NoneModule: Symbol

lazy val NotNullClass: ClassSymbol

object NothingClass extends BottomClassSymbol

object NullClass extends BottomClassSymbol

lazy val NullPointerExceptionClass: Symbol

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: Symbol

lazy val Object_eq: MethodSymbol

def Object_equals: Symbol

def Object_finalize: Symbol

def Object_getClass: Symbol

def Object_hashCode: Symbol

lazy val Object_isInstanceOf: MethodSymbol

lazy val Object_ne: MethodSymbol

def Object_notify: Symbol

def Object_notifyAll: Symbol

lazy val Object_synchronized: MethodSymbol

def Object_toString: Symbol

lazy val OptManifestClass: ClassSymbol

lazy val OptionClass: Symbol

lazy val ParamTargetClass: ClassSymbol

lazy val PartialFunctionClass: ClassSymbol

lazy val PartialManifestClass: ClassSymbol

lazy val PartialManifestModule: ModuleSymbol

lazy val PostfixOpsFeature: Symbol

lazy val PredefModule: ModuleSymbol

lazy val PredefModuleClass: Symbol

def Predef_???: Symbol

def Predef_classOf: Symbol

def Predef_conforms: Symbol

def Predef_identity: Symbol

def Predef_wrapRefArray: Symbol

lazy val ProductClass: Array[Symbol]

lazy val ProductRootClass: ClassSymbol

def Product_canEqual: MethodSymbol

def Product_iterator: MethodSymbol

def Product_productArity: MethodSymbol

def Product_productElement: MethodSymbol

def Product_productPrefix: MethodSymbol

def ReflectMirror: Symbol

def ReflectMirrorPrefix: _6.global.Tree forSome { val _6: Definitions.this.TreeGen{val global: Definitions.this.type} }

lazy val ReflectPackage: Symbol

lazy val ReflectPackageClass: Symbol

lazy val ReflectiveCallsFeature: Symbol

lazy val RemoteAttr: ClassSymbol

lazy val RemoteExceptionClass: ClassSymbol

lazy val RemoteInterfaceClass: ClassSymbol

lazy val RepeatedParamClass: ClassSymbol

object RootClass extends PackageClassSymbol with RootSymbol

object RootPackage extends PackageSymbol with RootSymbol

lazy val RuntimeNothingClass: Symbol

lazy val RuntimeNullClass: Symbol

lazy val RuntimePackage: PackageSymbol

lazy val RuntimePackageClass: Symbol

lazy val ScalaInlineClass: ClassSymbol

lazy val ScalaLongSignatureAnnotation: ClassSymbol

lazy val ScalaNoInlineClass: ClassSymbol

lazy val ScalaNumberClass: ClassSymbol

lazy val ScalaNumericValueClasses: List[ClassSymbol]

lazy val ScalaPackage: PackageSymbol

lazy val ScalaPackageClass: Symbol

def ScalaPrimitiveValueClasses: List[ClassSymbol]

lazy val ScalaRunTimeModule: Symbol

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: Symbol

lazy val SomeModule: Symbol

lazy val SpecializableModule: ModuleSymbol

Specialization.

lazy val SpecializedClass: ClassSymbol

lazy val StaticAnnotationClass: ClassSymbol

lazy val StringAddClass: ClassSymbol

lazy val StringAdd_+: Symbol

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: Symbol

lazy val Symbol_apply: Symbol

lazy val SysPackage: Symbol

def Sys_error: Symbol

lazy val TailrecClass: ClassSymbol

lazy val ThrowableClass: Symbol

lazy val ThrowsClass: ClassSymbol

lazy val TraitSetterAnnotationClass: ClassSymbol

lazy val TransientAttr: ClassSymbol

lazy val TraversableClass: ClassSymbol

lazy val TupleClass: Array[Symbol]

lazy val TypeConstraintClass: ClassSymbol

lazy val TypeTagClass: ClassSymbol

lazy val TypeTagModule: ModuleSymbol

def TypeTagTpe: MethodSymbol

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 ValueTypeClass: Symbol

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: Symbol

def arrayClassMethod: Symbol

def arrayCloneMethod: Symbol

def arrayElementClassMethod: Symbol

def arrayLengthMethod: Symbol

def arrayType(arg: Type): Type

def arrayUpdateMethod: Symbol

final def asInstanceOf[T0]: T0

def boundedClassType(upperBound: Type): Type

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

lazy val boxMethod: Map[Symbol, MethodSymbol]

lazy val boxedClass: Map[Symbol, Symbol]

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

def compilerSymbolFromTag(t: reflect.mirror.TypeTag[_]): Symbol

def compilerTypeFromTag(t: reflect.mirror.TypeTag[_]): Type

def delayedInitMethod: Symbol

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

var emptypackagescope: Scope

def ensureAccessibleMethod: Symbol

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

lazy val experimentalModule: Symbol

def finalize(): Unit

def findMemberFromRoot(fullName: Name): Symbol

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

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

def functionApply(n: Int): Symbol

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

final def getClass(): Class[_]

def getClassIfDefined(fullname: Name): Symbol

def getClassIfDefined(fullname: String): Symbol

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): MethodSymbol

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

def getModule(fullname: Name): ModuleSymbol

def getModuleIfDefined(fullname: Name): Symbol

def getModuleIfDefined(fullname: String): Symbol

def getPackage(fullname: Name): PackageSymbol

def getPackageObject(fullname: String): Symbol

def getPackageObjectClass(fullname: String): Symbol

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

if tpe <: ProductN[T1,.

def getRequiredClass(fullname: String): ClassSymbol

def getRequiredModule(fullname: String): ModuleSymbol

def getRequiredPackage(fullname: String): PackageSymbol

def hasJavaMainMethod(path: String): Boolean

def hasJavaMainMethod(sym: Symbol): Boolean

def hasRepeatedParam(tp: Type): Boolean

def hashCode(): Int

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

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 isProductNClass(sym: Symbol): Boolean

def isRepeatedParamType(tp: Type): Boolean

def isScalaRepeatedParamType(tp: Type): Boolean

def isScalaValueType(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 javaTypeName(jclazz: Class[_]): TypeName

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

lazy val languageFeatureModule: ModuleSymbol

lazy val metaAnnotations: Set[Symbol]

def methodCache_add: Symbol

def methodCache_find: Symbol

def methodClass_setAccessible: Symbol

var nbScalaCallers: Int

final def ne(arg0: AnyRef): Boolean

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

def newScalaCaller(delegateType: Type): Symbol

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

final def notifyAll(): Unit

lazy val numericWeight: Map[Symbol, Int]

def optionType(tp: Type): Type

def packageExists(packageName: String): Boolean

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

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

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

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 requiredClass[T](implicit arg0: ClassTag[T]): ClassSymbol

def requiredModule[T](implicit arg0: ClassTag[T]): ModuleSymbol

def scalaRepeatedType(arg: Type): Type

def scalaRuntimeSameElements: Symbol

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

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

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, MethodSymbol]

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 Predef_AnyRef: Symbol

def getClass(fullname: Name): Symbol

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.