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 BooleanClass(implicit ctx: Context): ClassSymbol

  47. val BooleanEnc: Int

  48. lazy val BooleanType: TypeRef

  49. def Boolean_!: Symbol

  50. def Boolean_&&: Symbol

  51. lazy val Boolean_andR: TermRef

  52. lazy val Boolean_notR: TermRef

  53. lazy val Boolean_orR: TermRef

  54. def Boolean_||: Symbol

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

  56. lazy val BoxedBooleanModule: TermSymbol

  57. lazy val BoxedBooleanType: TypeRef

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

  59. lazy val BoxedByteModule: TermSymbol

  60. lazy val BoxedByteType: TypeRef

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

  62. lazy val BoxedCharModule: TermSymbol

  63. lazy val BoxedCharType: TypeRef

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

  65. lazy val BoxedDoubleModule: TermSymbol

  66. lazy val BoxedDoubleType: TypeRef

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

  68. lazy val BoxedFloatModule: TermSymbol

  69. lazy val BoxedFloatType: TypeRef

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

  71. lazy val BoxedIntModule: TermSymbol

  72. lazy val BoxedIntType: TypeRef

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

  74. lazy val BoxedLongModule: TermSymbol

  75. lazy val BoxedLongType: TypeRef

  76. lazy val BoxedNumberClass: ClassSymbol

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

  78. lazy val BoxedShortModule: TermSymbol

  79. lazy val BoxedShortType: TypeRef

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

  81. lazy val BoxedUnitModule: TermSymbol

  82. lazy val BoxedUnitType: TypeRef

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

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

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

  86. lazy val BoxesRunTimeModuleRef: TermRef

  87. lazy val ByNameParamClass2x: ClassSymbol

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

  89. val ByteEnc: Int

  90. lazy val ByteType: TypeRef

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

  92. val CharEnc: Int

  93. lazy val CharType: TypeRef

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

  95. lazy val ChildAnnotType: TypeRef

  96. lazy val ClassCastExceptionClass: ClassSymbol

  97. lazy val ClassClass: ClassSymbol

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

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

  100. lazy val ClassTagType: TypeRef

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

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

  103. lazy val ClassfileAnnotationType: TypeRef

  104. lazy val ComparableClass: ClassSymbol

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

  106. lazy val ContravariantBetweenAnnotType: TypeRef

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

  108. lazy val CovariantBetweenAnnotType: TypeRef

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

  110. lazy val DeprecatedAnnotType: TypeRef

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

  112. lazy val DottyArraysModuleRef: TermRef

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

  114. lazy val DottyPredefModuleRef: TermRef

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

  116. val DoubleEnc: Int

  117. lazy val DoubleType: TypeRef

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

  119. lazy val DynamicType: TypeRef

  120. lazy val EmptyPackageClass: ClassSymbol

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

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

    The enumeration type, goven a value of the enumeration

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

  124. lazy val EqType: TypeRef

  125. lazy val EqualsPatternClass: ClassSymbol

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

  127. lazy val FieldMetaAnnotType: TypeRef

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

  129. val FloatEnc: Int

  130. lazy val FloatType: TypeRef

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

  132. lazy val Function0_applyR: TermRef

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

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

  135. object FunctionOf

  136. lazy val FunctionType: Array[TypeRef]

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

  138. lazy val GetterMetaAnnotType: TypeRef

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

  140. lazy val ImplicitNotFoundAnnotType: TypeRef

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

  142. val IntEnc: Int

  143. lazy val IntType: TypeRef

  144. def Int_*: Symbol

  145. def Int_+: Symbol

  146. def Int_-: Symbol

  147. def Int_/: Symbol

  148. def Int_<=: Symbol

  149. def Int_==: Symbol

  150. def Int_>=: Symbol

  151. lazy val Int_divR: TermRef

  152. lazy val Int_eqR: TermRef

  153. lazy val Int_geR: TermRef

  154. lazy val Int_leR: TermRef

  155. lazy val Int_minusR: TermRef

  156. lazy val Int_mulR: TermRef

  157. lazy val Int_plusR: TermRef

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

  159. lazy val InvariantBetweenAnnotType: TypeRef

  160. lazy val JavaCloneableClass: ClassSymbol

  161. lazy val JavaLangPackageVal: TermSymbol

  162. lazy val JavaPackageVal: TermSymbol

  163. lazy val JavaSerializableClass: ClassSymbol

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

  165. lazy val LanguageModuleRef: TermSymbol

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

  167. val LongEnc: Int

  168. lazy val LongType: TypeRef

  169. lazy val Long_LSR_Int: Symbol

  170. lazy val Long_XOR_Long: Symbol

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

  172. lazy val MatchErrorType: TypeRef

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

  174. lazy val MigrationAnnotType: TypeRef

  175. 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)

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

  177. lazy val NativeAnnotType: TypeRef

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

  179. lazy val NilModuleRef: TermRef

  180. lazy val NonLocalReturnControlType: TypeRef

  181. lazy val NothingClass: ClassSymbol

  182. def NothingType: TypeRef

  183. lazy val NullClass: ClassSymbol

  184. lazy val NullPointerExceptionClass: ClassSymbol

  185. def NullType: TypeRef

  186. lazy val ObjectClass: ClassSymbol

  187. def ObjectMethods: List[TermSymbol]

  188. def ObjectType: TypeRef

  189. lazy val Object_clone: TermSymbol

  190. lazy val Object_eq: TermSymbol

  191. lazy val Object_finalize: TermSymbol

  192. lazy val Object_ne: TermSymbol

  193. lazy val Object_notify: TermSymbol

  194. lazy val Object_notifyAll: TermSymbol

  195. lazy val Object_synchronized: TermSymbol

  196. lazy val Object_wait: TermSymbol

  197. lazy val Object_waitL: TermSymbol

  198. lazy val Object_waitLI: TermSymbol

  199. lazy val OpsPackageClass: ClassSymbol

  200. 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

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

  202. lazy val OptionType: TypeRef

  203. def PairClass(implicit ctx: Context): ClassSymbol

  204. lazy val PairType: TypeRef

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

  206. lazy val PartialFunctionType: TypeRef

  207. lazy val PhantomClasses: Set[Symbol]

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

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

  210. lazy val Predef_classOfR: TermRef

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

  212. lazy val Predef_conformsR: TermRef

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

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

  215. lazy val ProductNType: Array[TypeRef]

  216. lazy val ProductType: TypeRef

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

  218. lazy val Product_canEqualR: TermRef

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

  220. lazy val Product_productArityR: TermRef

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

  222. lazy val Product_productPrefixR: TermRef

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

  224. lazy val RemoteAnnotType: TypeRef

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

  226. lazy val RepeatedAnnotType: TypeRef

  227. lazy val RepeatedParamClass: ClassSymbol

  228. def RepeatedParamType: TypeRef

  229. lazy val RootClass: ClassSymbol

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

  231. lazy val RootImportTypes: List[TermRef]

  232. lazy val RootPackage: TermSymbol

  233. def Scala2LanguageModuleClass(implicit ctx: Context): ClassSymbol

  234. lazy val Scala2LanguageModuleRef: TermSymbol

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

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

  237. lazy val ScalaLongSignatureAnnotType: TypeRef

  238. lazy val ScalaMathPackageVal: TermSymbol

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

  240. lazy val ScalaNumericValueTypeList: List[TypeRef]

  241. lazy val ScalaPackageClass: ClassSymbol

  242. lazy val ScalaPackageVal: TermSymbol

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

  244. lazy val ScalaPredefModuleRef: TermRef

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

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

  247. lazy val ScalaRuntimeModuleRef: TermRef

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

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

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

  251. lazy val ScalaSignatureAnnotType: TypeRef

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

  253. lazy val ScalaStaticAnnotType: TypeRef

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

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

  256. lazy val ScalaStaticsModuleRef: TermRef

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

  258. lazy val ScalaStrictFPAnnotType: TypeRef

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

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

  261. lazy val SeqType: TypeRef

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

  263. lazy val Seq_applyR: TermRef

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

  265. lazy val Seq_headR: TermRef

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

  267. lazy val SerialVersionUIDAnnotType: TypeRef

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

  269. lazy val SerializableType: TypeRef

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

  271. lazy val SetterMetaAnnotType: TypeRef

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

  273. val ShortEnc: Int

  274. lazy val ShortType: TypeRef

  275. lazy val SingletonClass: ClassSymbol

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

  277. lazy val SourceFileAnnotType: TypeRef

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

  279. lazy val StaticAnnotationType: TypeRef

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

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

  282. lazy val StringAddType: TypeRef

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

  284. lazy val StringAdd_plusR: TermRef

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

  286. lazy val StringBuilderType: TypeRef

  287. lazy val StringClass: ClassSymbol

  288. lazy val StringModule: Symbol

  289. def StringType: Type

  290. lazy val String_+: TermSymbol

  291. lazy val String_valueOf_Object: Symbol

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

  293. lazy val SwitchAnnotType: TypeRef

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

  295. lazy val SymbolType: TypeRef

  296. lazy val SysPackage: TermSymbol

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

  298. lazy val Sys_errorR: TermRef

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

  300. lazy val TASTYLongSignatureAnnotType: TypeRef

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

  302. lazy val TASTYSignatureAnnotType: TypeRef

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

  304. lazy val TailrecAnnotType: TypeRef

  305. lazy val ThrowableClass: ClassSymbol

  306. def ThrowableType: TypeRef

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

  308. lazy val ThrowsAnnotType: TypeRef

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

  310. lazy val TransientAnnotType: TypeRef

  311. lazy val TupleType: Array[TypeRef]

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

  313. lazy val UncheckedAnnotType: TypeRef

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

  315. lazy val UncheckedStableAnnotType: TypeRef

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

  317. lazy val UncheckedVarianceAnnotType: TypeRef

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

  319. val UnitEnc: Int

  320. lazy val UnitType: TypeRef

  321. lazy val UnqualifiedOwnerTypes: Set[NamedType]

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

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

  323. lazy val UnsafeNonvariantAnnotType: TypeRef

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

  325. lazy val VolatileAnnotType: TypeRef

  326. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

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

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

  328. def clone(): AnyRef

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

  329. lazy val dummyApply: TermSymbol

    Dummy method needed by elimByName

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

    Definition Classes
    AnyRef

  331. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  332. def finalize(): Unit

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

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

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

    Definition Classes
    AnyRef → Any

  335. def hashCode(): Int

    Definition Classes
    AnyRef → Any

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

  337. def isAbstractFunctionClass(cls: Symbol): Boolean

  338. def isBottomClass(cls: Symbol): Boolean

  339. def isBottomType(tp: Type): Boolean

  340. def isFunctionClass(cls: Symbol): Boolean

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

  342. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  343. def isPolymorphicAfterErasure(sym: Symbol): Boolean

  344. def isProductClass(cls: Symbol): Boolean

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

  346. def isTupleClass(cls: Symbol): Boolean

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

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

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

  350. def methOfAny(tp: Type): MethodType

  351. def methOfAnyRef(tp: Type): MethodType

  352. def methOfAnyVal(tp: Type): MethodType

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

    Definition Classes
    AnyRef

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

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

  356. final def notify(): Unit

    Definition Classes
    AnyRef

  357. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  358. def runtimeMethodRef(name: PreName): TermRef

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

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

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

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

  361. def staticsMethod(name: PreName): TermSymbol

  362. def staticsMethodRef(name: PreName): TermRef

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

    Definition Classes
    AnyRef

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

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

  365. lazy val syntheticCoreMethods: List[TermSymbol]

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

  366. lazy val throwMethod: TermSymbol

    Method representing a throw

  367. def toString(): String

    Definition Classes
    AnyRef → Any

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

  369. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  372. def wrapArrayMethodName(elemtp: Type): TermName

Inherited from AnyRef

Inherited from Any

Ungrouped