dotty.tools.dotc.core

Definitions

Related Docs: object Definitions | package core

class Definitions extends AnyRef

A class defining symbols and types of standard definitions

Note: There's a much nicer design possible once we have implicit functions. The idea is explored to some degree in branch wip-definitions (#929): Instead of a type and a separate symbol definition, we produce in one line an implicit function from Context to Symbol, and possibly also the corresponding type. This cuts down on all the duplication encountered here.

wip-definitions tries to do the same with an implicit conversion from a SymbolPerRun type to a symbol type. The problem with that is universal equality. Comparisons will not trigger the conversion and will therefore likely return false results.

So the branch is put on hold, until we have implicit functions, which will always automatically be dereferenced.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Definitions
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Definitions()

Type Members

  1. class PerRun[T] extends AnyRef

    This class would also be obviated by the implicit function type design

  2. type PrimitiveClassEnc = Int

Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Definition Classes
    AnyRef → Any

  3. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  4. def AbstractFunctionClass(n: Int)(implicit ctx: Context): Symbol

  5. val AbstractFunctionClassPerRun: PerRun[Array[Symbol]]

  6. lazy val AbstractFunctionType: Array[TypeRef]

  7. def AbstractPartialFunctionClass(implicit ctx: Context): ClassSymbol

  8. lazy val AbstractPartialFunctionType: TypeRef

  9. def AliasAnnot(implicit ctx: Context): ClassSymbol

  10. lazy val AliasAnnotType: TypeRef

  11. def AnnotationClass(implicit ctx: Context): ClassSymbol

  12. def AnnotationDefaultAnnot(implicit ctx: Context): ClassSymbol

  13. lazy val AnnotationDefaultAnnotType: TypeRef

  14. lazy val AnnotationType: TypeRef

  15. lazy val AnyClass: ClassSymbol

    Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter) because after erasure the Any and AnyVal references get remapped to the Object methods which would result in a double binding assertion failure.

    Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter) because after erasure the Any and AnyVal references get remapped to the Object methods which would result in a double binding assertion failure. Instead we do the following:

    • Have some methods exist only in Any, and remap them with the Erasure denotation transformer to be owned by Object.
    • Have other methods exist only in Object. To achieve this, we synthesize all Any and Object methods; Object methods no longer get loaded from a classfile.

    There's a remaining question about getClass. In Scala2.x getClass was handled by compiler magic. This is deemed too cumersome for Dotty and therefore right now getClass gets no special treatment; it's just a method on Any which returns the raw type java.lang.Class. An alternative way to get better getClass typing would be to treat getClass as a method of a generic decorator which gets remapped in a later phase to Object#getClass. Then we could give it the right type without changing the typechecker:

    implicit class AnyGetClass[T](val x: T) extends AnyVal { def getClass: java.lang.Class[T] = ??? }

  16. def AnyMethods: List[TermSymbol]

  17. lazy val AnyRefAlias: TypeSymbol

  18. def AnyRefType: TypeRef

  19. def AnyType: TypeRef

  20. lazy val AnyValClass: ClassSymbol

  21. def AnyValType: TypeRef

  22. lazy val Any_!=: TermSymbol

  23. lazy val Any_##: TermSymbol

  24. lazy val Any_==: TermSymbol

  25. lazy val Any_asInstanceOf: TermSymbol

  26. lazy val Any_equals: TermSymbol

  27. lazy val Any_getClass: TermSymbol

  28. lazy val Any_hashCode: TermSymbol

  29. lazy val Any_isInstanceOf: TermSymbol

  30. lazy val Any_toString: TermSymbol

  31. def ArrayClass(implicit ctx: Context): ClassSymbol

  32. def ArrayConstructor(implicit ctx: Context): Symbol

  33. lazy val ArrayConstructorR: TermRef

  34. def ArrayModule(implicit ctx: Context): ClassSymbol

  35. lazy val ArrayModuleType: TermRef

  36. object ArrayOf

  37. lazy val ArrayType: TypeRef

  38. def Array_apply(implicit ctx: Context): Symbol

  39. lazy val Array_applyR: TermRef

  40. def Array_clone(implicit ctx: Context): Symbol

  41. lazy val Array_cloneR: TermRef

  42. def Array_length(implicit ctx: Context): Symbol

  43. lazy val Array_lengthR: TermRef

  44. def Array_update(implicit ctx: Context): Symbol

  45. lazy val Array_updateR: TermRef

  46. def BodyAnnot(implicit ctx: Context): ClassSymbol

  47. lazy val BodyAnnotType: TypeRef

  48. def BooleanClass(implicit ctx: Context): ClassSymbol

  49. val BooleanEnc: Int

  50. lazy val BooleanType: TypeRef

  51. def Boolean_!: Symbol

  52. def Boolean_&&: Symbol

  53. lazy val Boolean_andR: TermRef

  54. lazy val Boolean_notR: TermRef

  55. lazy val Boolean_orR: TermRef

  56. def Boolean_||: Symbol

  57. def BoxedBooleanClass(implicit ctx: Context): ClassSymbol

  58. lazy val BoxedBooleanModule: TermSymbol

  59. lazy val BoxedBooleanType: TypeRef

  60. def BoxedByteClass(implicit ctx: Context): ClassSymbol

  61. lazy val BoxedByteModule: TermSymbol

  62. lazy val BoxedByteType: TypeRef

  63. def BoxedCharClass(implicit ctx: Context): ClassSymbol

  64. lazy val BoxedCharModule: TermSymbol

  65. lazy val BoxedCharType: TypeRef

  66. def BoxedDoubleClass(implicit ctx: Context): ClassSymbol

  67. lazy val BoxedDoubleModule: TermSymbol

  68. lazy val BoxedDoubleType: TypeRef

  69. def BoxedFloatClass(implicit ctx: Context): ClassSymbol

  70. lazy val BoxedFloatModule: TermSymbol

  71. lazy val BoxedFloatType: TypeRef

  72. def BoxedIntClass(implicit ctx: Context): ClassSymbol

  73. lazy val BoxedIntModule: TermSymbol

  74. lazy val BoxedIntType: TypeRef

  75. def BoxedLongClass(implicit ctx: Context): ClassSymbol

  76. lazy val BoxedLongModule: TermSymbol

  77. lazy val BoxedLongType: TypeRef

  78. lazy val BoxedNumberClass: ClassSymbol

  79. def BoxedShortClass(implicit ctx: Context): ClassSymbol

  80. lazy val BoxedShortModule: TermSymbol

  81. lazy val BoxedShortType: TypeRef

  82. def BoxedUnitClass(implicit ctx: Context): ClassSymbol

  83. lazy val BoxedUnitModule: TermSymbol

  84. lazy val BoxedUnitType: TypeRef

  85. def BoxedUnit_UNIT(implicit ctx: Context): TermSymbol

  86. def BoxesRunTimeClass(implicit ctx: Context): ClassSymbol

  87. def BoxesRunTimeModule(implicit ctx: Context): Symbol

  88. lazy val BoxesRunTimeModuleRef: TermRef

  89. lazy val ByNameParamClass2x: ClassSymbol

  90. def ByteClass(implicit ctx: Context): ClassSymbol

  91. val ByteEnc: Int

  92. lazy val ByteType: TypeRef

  93. def CharClass(implicit ctx: Context): ClassSymbol

  94. val CharEnc: Int

  95. lazy val CharType: TypeRef

  96. def ChildAnnot(implicit ctx: Context): ClassSymbol

  97. lazy val ChildAnnotType: TypeRef

  98. lazy val ClassCastExceptionClass: ClassSymbol

  99. lazy val ClassClass: ClassSymbol

  100. def ClassTagClass(implicit ctx: Context): ClassSymbol

  101. def ClassTagModule(implicit ctx: Context): Symbol

  102. lazy val ClassTagType: TypeRef

  103. def ClassType(arg: Type)(implicit ctx: Context): Type

  104. def ClassfileAnnotationClass(implicit ctx: Context): ClassSymbol

  105. lazy val ClassfileAnnotationType: TypeRef

  106. lazy val ComparableClass: ClassSymbol

  107. def ContravariantBetweenAnnot(implicit ctx: Context): ClassSymbol

  108. lazy val ContravariantBetweenAnnotType: TypeRef

  109. def CovariantBetweenAnnot(implicit ctx: Context): ClassSymbol

  110. lazy val CovariantBetweenAnnotType: TypeRef

  111. def DeprecatedAnnot(implicit ctx: Context): ClassSymbol

  112. lazy val DeprecatedAnnotType: TypeRef

  113. def DottyArraysModule(implicit ctx: Context): Symbol

  114. lazy val DottyArraysModuleRef: TermRef

  115. def DottyPredefModule(implicit ctx: Context): Symbol

  116. lazy val DottyPredefModuleRef: TermRef

  117. def DoubleClass(implicit ctx: Context): ClassSymbol

  118. val DoubleEnc: Int

  119. lazy val DoubleType: TypeRef

  120. def DynamicClass(implicit ctx: Context): ClassSymbol

  121. lazy val DynamicType: TypeRef

  122. lazy val EmptyPackageClass: ClassSymbol

  123. lazy val EmptyPackageVal: Symbol { type ThisName = dotty.tools.dotc.core.Names.TermName }

  124. def EnumType(sym: Symbol)(implicit ctx: Context): TypeRef

    The enumeration type, goven a value of the enumeration

  125. def EqClass(implicit ctx: Context): ClassSymbol

  126. lazy val EqType: TypeRef

  127. lazy val EqualsPatternClass: ClassSymbol

  128. def FieldMetaAnnot(implicit ctx: Context): ClassSymbol

  129. lazy val FieldMetaAnnotType: TypeRef

  130. def FloatClass(implicit ctx: Context): ClassSymbol

  131. val FloatEnc: Int

  132. lazy val FloatType: TypeRef

  133. def Function0_apply(implicit ctx: Context): Symbol

  134. lazy val Function0_applyR: TermRef

  135. def FunctionClass(n: Int)(implicit ctx: Context): Symbol

  136. def FunctionClassPerRun: PerRun[Array[Symbol]]

  137. object FunctionOf

  138. lazy val FunctionType: Array[TypeRef]

  139. def GetterMetaAnnot(implicit ctx: Context): ClassSymbol

  140. lazy val GetterMetaAnnotType: TypeRef

  141. def ImplicitNotFoundAnnot(implicit ctx: Context): ClassSymbol

  142. lazy val ImplicitNotFoundAnnotType: TypeRef

  143. def InlineAnnot(implicit ctx: Context): ClassSymbol

  144. lazy val InlineAnnotType: TypeRef

  145. def InlineParamAnnot(implicit ctx: Context): ClassSymbol

  146. lazy val InlineParamAnnotType: TypeRef

  147. def IntClass(implicit ctx: Context): ClassSymbol

  148. val IntEnc: Int

  149. lazy val IntType: TypeRef

  150. def Int_*: Symbol

  151. def Int_+: Symbol

  152. def Int_-: Symbol

  153. def Int_/: Symbol

  154. def Int_<=: Symbol

  155. def Int_==: Symbol

  156. def Int_>=: Symbol

  157. lazy val Int_divR: TermRef

  158. lazy val Int_eqR: TermRef

  159. lazy val Int_geR: TermRef

  160. lazy val Int_leR: TermRef

  161. lazy val Int_minusR: TermRef

  162. lazy val Int_mulR: TermRef

  163. lazy val Int_plusR: TermRef

  164. def InvariantBetweenAnnot(implicit ctx: Context): ClassSymbol

  165. lazy val InvariantBetweenAnnotType: TypeRef

  166. lazy val JavaCloneableClass: ClassSymbol

  167. lazy val JavaLangPackageVal: TermSymbol

  168. lazy val JavaPackageVal: TermSymbol

  169. lazy val JavaSerializableClass: ClassSymbol

  170. def LanguageModuleClass(implicit ctx: Context): ClassSymbol

  171. lazy val LanguageModuleRef: TermSymbol

  172. def LongClass(implicit ctx: Context): ClassSymbol

  173. val LongEnc: Int

  174. lazy val LongType: TypeRef

  175. lazy val Long_LSR_Int: Symbol

  176. lazy val Long_XOR_Long: Symbol

  177. def MatchErrorClass(implicit ctx: Context): ClassSymbol

  178. lazy val MatchErrorType: TypeRef

  179. def MigrationAnnot(implicit ctx: Context): ClassSymbol

  180. lazy val MigrationAnnotType: TypeRef

  181. object MultiArrayOf

    An extractor for multi-dimensional arrays.

    An extractor for multi-dimensional arrays. Note that this will also extract the high bound if an element type is a wildcard. E.g.

    Array[_ <: Array[_ <: Number]]

    would match

    MultiArrayOf(<Number>, 2)

  182. def NativeAnnot(implicit ctx: Context): ClassSymbol

  183. lazy val NativeAnnotType: TypeRef

  184. def NilModule(implicit ctx: Context): Symbol

  185. lazy val NilModuleRef: TermRef

  186. lazy val NonLocalReturnControlType: TypeRef

  187. lazy val NothingClass: ClassSymbol

  188. def NothingType: TypeRef

  189. lazy val NullClass: ClassSymbol

  190. lazy val NullPointerExceptionClass: ClassSymbol

  191. def NullType: TypeRef

  192. lazy val ObjectClass: ClassSymbol

  193. def ObjectMethods: List[TermSymbol]

  194. def ObjectType: TypeRef

  195. lazy val Object_clone: TermSymbol

  196. lazy val Object_eq: TermSymbol

  197. lazy val Object_finalize: TermSymbol

  198. lazy val Object_ne: TermSymbol

  199. lazy val Object_notify: TermSymbol

  200. lazy val Object_notifyAll: TermSymbol

  201. lazy val Object_synchronized: TermSymbol

  202. lazy val Object_wait: TermSymbol

  203. lazy val Object_waitL: TermSymbol

  204. lazy val Object_waitLI: TermSymbol

  205. lazy val OpsPackageClass: ClassSymbol

  206. lazy val OpsPackageVal: Symbol { type ThisName = dotty.tools.dotc.core.Names.TermName }

    A package in which we can place all methods that are interpreted specially by the compiler

  207. def OptionClass(implicit ctx: Context): ClassSymbol

  208. lazy val OptionType: TypeRef

  209. def PartialFunctionClass(implicit ctx: Context): ClassSymbol

  210. lazy val PartialFunctionType: TypeRef

  211. lazy val PhantomClasses: Set[Symbol]

  212. val PredefImportFns: List[() ⇒ TermRef]

  213. def Predef_classOf(implicit ctx: Context): Symbol

  214. lazy val Predef_classOfR: TermRef

  215. def Predef_conforms(implicit ctx: Context): Symbol

  216. lazy val Predef_conformsR: TermRef

  217. def Predef_eqAny(implicit ctx: Context): TermSymbol

  218. def ProductClass(implicit ctx: Context): ClassSymbol

  219. lazy val ProductNType: Array[TypeRef]

  220. lazy val ProductType: TypeRef

  221. def Product_canEqual(implicit ctx: Context): Symbol

  222. lazy val Product_canEqualR: TermRef

  223. def Product_productArity(implicit ctx: Context): Symbol

  224. lazy val Product_productArityR: TermRef

  225. def Product_productPrefix(implicit ctx: Context): Symbol

  226. lazy val Product_productPrefixR: TermRef

  227. def RemoteAnnot(implicit ctx: Context): ClassSymbol

  228. lazy val RemoteAnnotType: TypeRef

  229. def RepeatedAnnot(implicit ctx: Context): ClassSymbol

  230. lazy val RepeatedAnnotType: TypeRef

  231. lazy val RepeatedParamClass: ClassSymbol

  232. def RepeatedParamType: TypeRef

  233. lazy val RootClass: ClassSymbol

  234. lazy val RootImportFns: List[() ⇒ TermRef]

  235. lazy val RootImportTypes: List[TermRef]

  236. lazy val RootPackage: TermSymbol

  237. val ScalaBoxedClasses: PerRun[Set[Symbol]]

  238. def ScalaLongSignatureAnnot(implicit ctx: Context): ClassSymbol

  239. lazy val ScalaLongSignatureAnnotType: TypeRef

  240. lazy val ScalaMathPackageVal: TermSymbol

  241. val ScalaNumericValueClasses: PerRun[Set[Symbol]]

  242. lazy val ScalaNumericValueTypeList: List[TypeRef]

  243. lazy val ScalaPackageClass: ClassSymbol

  244. lazy val ScalaPackageVal: TermSymbol

  245. def ScalaPredefModule(implicit ctx: Context): Symbol

  246. lazy val ScalaPredefModuleRef: TermRef

  247. def ScalaRuntimeClass(implicit ctx: Context): ClassSymbol

  248. def ScalaRuntimeModule(implicit ctx: Context): Symbol

  249. lazy val ScalaRuntimeModuleRef: TermRef

  250. def ScalaRuntime_drop(implicit ctx: Context): Symbol

  251. def ScalaRuntime_dropR(implicit ctx: Context): TermRef

  252. lazy val ScalaShadowingPackageClass: ClassSymbol

  253. lazy val ScalaShadowingPackageVal: TermSymbol

    The scalaShadowing package is used to safely modify classes and objects in scala so that they can be used from dotty.

    The scalaShadowing package is used to safely modify classes and objects in scala so that they can be used from dotty. They will be visible as members of the scala package, replacing any objects or classes with the same name. But their binary artifacts are in scalaShadowing so they don't clash with the same-named scala members at runtime.

  254. def ScalaSignatureAnnot(implicit ctx: Context): ClassSymbol

  255. lazy val ScalaSignatureAnnotType: TypeRef

  256. def ScalaStaticAnnot(implicit ctx: Context): ClassSymbol

  257. lazy val ScalaStaticAnnotType: TypeRef

  258. def ScalaStaticsClass(implicit ctx: Context): ClassSymbol

  259. def ScalaStaticsModule(implicit ctx: Context): Symbol

  260. lazy val ScalaStaticsModuleRef: TermRef

  261. def ScalaStrictFPAnnot(implicit ctx: Context): ClassSymbol

  262. lazy val ScalaStrictFPAnnotType: TypeRef

  263. val ScalaValueClasses: PerRun[Set[Symbol]]

  264. def SeqClass(implicit ctx: Context): ClassSymbol

  265. lazy val SeqType: TypeRef

  266. def Seq_apply(implicit ctx: Context): Symbol

  267. lazy val Seq_applyR: TermRef

  268. def Seq_head(implicit ctx: Context): Symbol

  269. lazy val Seq_headR: TermRef

  270. def SerialVersionUIDAnnot(implicit ctx: Context): ClassSymbol

  271. lazy val SerialVersionUIDAnnotType: TypeRef

  272. def SerializableClass(implicit ctx: Context): ClassSymbol

  273. lazy val SerializableType: TypeRef

  274. def SetterMetaAnnot(implicit ctx: Context): ClassSymbol

  275. lazy val SetterMetaAnnotType: TypeRef

  276. def ShortClass(implicit ctx: Context): ClassSymbol

  277. val ShortEnc: Int

  278. lazy val ShortType: TypeRef

  279. lazy val SingletonClass: ClassSymbol

  280. def SourceFileAnnot(implicit ctx: Context): ClassSymbol

  281. lazy val SourceFileAnnotType: TypeRef

  282. def StaticAnnotationClass(implicit ctx: Context): ClassSymbol

  283. lazy val StaticAnnotationType: TypeRef

  284. val StaticRootImportFns: List[() ⇒ TermRef]

  285. def StringAddClass(implicit ctx: Context): ClassSymbol

  286. lazy val StringAddType: TypeRef

  287. def StringAdd_+(implicit ctx: Context): Symbol

  288. lazy val StringAdd_plusR: TermRef

  289. def StringBuilderClass(implicit ctx: Context): ClassSymbol

  290. lazy val StringBuilderType: TypeRef

  291. lazy val StringClass: ClassSymbol

  292. lazy val StringModule: Symbol

  293. def StringType: Type

  294. lazy val String_+: TermSymbol

  295. lazy val String_valueOf_Object: Symbol

  296. def SwitchAnnot(implicit ctx: Context): ClassSymbol

  297. lazy val SwitchAnnotType: TypeRef

  298. def SymbolClass(implicit ctx: Context): ClassSymbol

  299. lazy val SymbolType: TypeRef

  300. lazy val SysPackage: TermSymbol

  301. def Sys_error(implicit ctx: Context): Symbol

  302. lazy val Sys_errorR: TermRef

  303. def TASTYLongSignatureAnnot(implicit ctx: Context): ClassSymbol

  304. lazy val TASTYLongSignatureAnnotType: TypeRef

  305. def TASTYSignatureAnnot(implicit ctx: Context): ClassSymbol

  306. lazy val TASTYSignatureAnnotType: TypeRef

  307. def TailrecAnnot(implicit ctx: Context): ClassSymbol

  308. lazy val TailrecAnnotType: TypeRef

  309. lazy val ThrowableClass: ClassSymbol

  310. def ThrowableType: TypeRef

  311. def ThrowsAnnot(implicit ctx: Context): ClassSymbol

  312. lazy val ThrowsAnnotType: TypeRef

  313. def TransientAnnot(implicit ctx: Context): ClassSymbol

  314. lazy val TransientAnnotType: TypeRef

  315. lazy val TupleType: Array[TypeRef]

  316. def UncheckedAnnot(implicit ctx: Context): ClassSymbol

  317. lazy val UncheckedAnnotType: TypeRef

  318. def UncheckedStableAnnot(implicit ctx: Context): ClassSymbol

  319. lazy val UncheckedStableAnnotType: TypeRef

  320. def UncheckedVarianceAnnot(implicit ctx: Context): ClassSymbol

  321. lazy val UncheckedVarianceAnnotType: TypeRef

  322. def UnitClass(implicit ctx: Context): ClassSymbol

  323. val UnitEnc: Int

  324. lazy val UnitType: TypeRef

  325. lazy val UnqualifiedOwnerTypes: Set[NamedType]

    Modules whose members are in the default namespace and their module classes

  326. def UnsafeNonvariantAnnot(implicit ctx: Context): ClassSymbol

  327. lazy val UnsafeNonvariantAnnotType: TypeRef

  328. def VolatileAnnot(implicit ctx: Context): ClassSymbol

  329. lazy val VolatileAnnotType: TypeRef

  330. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  331. def boxedType(tp: Type)(implicit ctx: Context): TypeRef

    The type of the boxed class corresponding to primitive value type tp.

  332. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  333. lazy val dummyApply: TermSymbol

    Dummy method needed by elimByName

  334. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  335. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  336. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  337. def functionArity(tp: Type)(implicit ctx: Context): Int

  338. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  339. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  340. def init()(implicit ctx: Context): Unit

  341. def isAbstractFunctionClass(cls: Symbol): Boolean

  342. def isBottomClass(cls: Symbol): Boolean

  343. def isBottomType(tp: Type): Boolean

  344. def isFunctionClass(cls: Symbol): Boolean

  345. def isFunctionType(tp: Type)(implicit ctx: Context): Boolean

  346. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  347. def isPolymorphicAfterErasure(sym: Symbol): Boolean

  348. def isProductClass(cls: Symbol): Boolean

  349. def isProductSubType(tp: Type)(implicit ctx: Context): Boolean

  350. def isTupleClass(cls: Symbol): Boolean

  351. def isTupleType(tp: Type)(implicit ctx: Context): Boolean

  352. def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean

  353. def isValueSubType(tref1: TypeRef, tref2: TypeRef)(implicit ctx: Context): Boolean

  354. def methOfAny(tp: Type): MethodType

  355. def methOfAnyRef(tp: Type): MethodType

  356. def methOfAnyVal(tp: Type): MethodType

  357. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  358. def newArrayMethod(implicit ctx: Context): TermSymbol

  359. def newGenericArrayMethod(implicit ctx: Context): TermSymbol

  360. final def notify(): Unit

    Definition Classes
    AnyRef

  361. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  362. lazy val reservedScalaClassNames: Set[Name]

  363. def runtimeMethodRef(name: PreName): TermRef

  364. def scalaClassName(ref: Type)(implicit ctx: Context): TypeName

    If type ref refers to a class in the scala package, its name, otherwise EmptyTypeName

  365. def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName

    If cls is a class in the scala package, its name, otherwise EmptyTypeName

  366. def staticsMethod(name: PreName): TermSymbol

  367. def staticsMethodRef(name: PreName): TermRef

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

    Definition Classes
    AnyRef

  369. lazy val syntheticCoreClasses: List[Symbol { type ThisName >: dotty.tools.dotc.core.Names.TypeName with dotty.tools.dotc.core.Names.TermName <: dotty.tools.dotc.core.Names.Name{type ThisName >: dotty.tools.dotc.core.Names.TypeName with dotty.tools.dotc.core.Names.TermName <: dotty.tools.dotc.core.Names.Name} }]

  370. lazy val syntheticCoreMethods: List[TermSymbol]

    Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe

  371. lazy val syntheticScalaClasses: List[TypeSymbol]

    Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe

  372. lazy val throwMethod: TermSymbol

    Method representing a throw

  373. def toString(): String

    Definition Classes
    AnyRef → Any

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

  375. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  377. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  378. def wrapArrayMethodName(elemtp: Type): TermName

Inherited from AnyRef

Inherited from Any

Ungrouped