abstract class BTypes extends AnyRef
The BTypes component defines The BType class hierarchy. A BType stores all type information that is required after building the ASM nodes. This includes optimizations, generation of InnerClass attributes and generation of stack map frames.
The representation is immutable and independent of the compiler data structures, hence it can be queried by concurrent threads.
- Source
- BTypes.scala
- Alphabetic
- By Inheritance
- BTypes
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new BTypes()
Type Members
- final case class ArrayBType(componentType: BType) extends RefBType with Product with Serializable
- sealed abstract class BType extends AnyRef
- sealed abstract class ClassBType extends RefBType
A ClassBType represents a class or interface type.
A ClassBType represents a class or interface type. The necessary information to build a ClassBType is extracted from compiler symbols and types, see BTypesFromSymbols.
The
info
field contains either the class information on an error message why the info could not be computed. There are two reasons for an erroneous info:- The ClassBType was built from a class symbol that stems from a java source file, and the symbol's type could not be completed successfully (scala/bug#9111) 2. The ClassBType should be built from a classfile, but the class could not be found on the compilation classpath.
Note that all ClassBTypes required in a non-optimized run are built during code generation from the class symbols referenced by the ASTs, so they have a valid info. Therefore the backend often invokes
info.get
(which asserts the info to exist) when reading data from the ClassBType.The inliner on the other hand uses ClassBTypes that are built from classfiles, which may have a missing info. In order not to crash the compiler unnecessarily, the inliner does not force infos using
get
, but it reports inliner warnings for missing infos that prevent inlining. - final case class ClassInfo(superClass: Option[ClassBType], interfaces: List[ClassBType], flags: Int, nestedClasses: Lazy[List[ClassBType]], nestedInfo: Lazy[Option[NestedInfo]], inlineInfo: InlineInfo) extends Product with Serializable
The type info for a class.
The type info for a class. Used for symboltable-independent subtype checks in the backend.
- superClass
The super class, not defined for class java/lang/Object.
- interfaces
All transitively implemented interfaces, except for those inherited through the superclass.
- flags
The java flags, obtained through
javaFlags
. Used also to derive the flags for InnerClass entries.- nestedClasses
Classes nested in this class. Those need to be added to the InnerClass table, see the InnerClass spec summary above.
- nestedInfo
If this describes a nested class, information for the InnerClass table.
- inlineInfo
Information about this class for the inliner.
- final case class InnerClassEntry(name: String, outerName: String, innerName: String, flags: Int) extends Product with Serializable
This class holds the data for an entry in the InnerClass table.
This class holds the data for an entry in the InnerClass table. See the InnerClass summary above in this file.
There's some overlap with the class NestedInfo, but it's not exactly the same and cleaner to keep separate.
- name
The internal name of the class.
- outerName
The internal name of the outer class, may be null.
- innerName
The simple name of the inner class, may be null.
- flags
The flags for this class in the InnerClass entry.
- sealed abstract class Lazy[+T] extends AnyRef
- class LazyVar[T] extends AnyRef
This implements a lazy value that can be reset and re-initialized.
This implements a lazy value that can be reset and re-initialized. It synchronizes on
frontendLock
so that lazy state created through this utility can be safely initialized in the post-processor.Note that values defined as
LazyVar
s are usuallylazy val
s themselves (created through theperRunLazy
method). This ensures that re-initializing a component only clears thoseLazyVar
s that have actually been used in the previous compiler run. - final case class MethodBType(argumentTypes: Array[BType], returnType: BType) extends BType with Product with Serializable
- final case class MethodNameAndType(name: String, methodType: MethodBType) extends Product with Serializable
Just a named pair, used in CoreBTypes.srBoxesRuntimeBoxToMethods/srBoxesRuntimeUnboxToMethods.
- final case class NestedInfo(enclosingClass: ClassBType, outerName: Option[String], innerName: Option[String], isStaticNestedClass: Boolean, enteringTyperPrivate: Boolean) extends Product with Serializable
Information required to add a class to an InnerClass table.
Information required to add a class to an InnerClass table. The spec summary above explains what information is required for the InnerClass entry.
- enclosingClass
The enclosing class, if it is also nested. When adding a class to the InnerClass table, enclosing nested classes are also added.
- outerName
The outerName field in the InnerClass entry, may be None.
- innerName
The innerName field, may be None.
- isStaticNestedClass
True if this is a static nested class (not inner class) (*) (*) Note that the STATIC flag in ClassInfo.flags, obtained through javaFlags(classSym), is not correct for the InnerClass entry, see javaFlags. The static flag in the InnerClass describes a source-level property: if the class is in a static context (does not have an outer pointer). This is checked when building the NestedInfo.
- sealed abstract class PrimitiveBType extends BType
- sealed abstract class RefBType extends BType
Abstract Value Members
- abstract val coreBTypes: CoreBTypes { val bTypes: BTypes.this.type }
- abstract val frontendAccess: PostProcessorFrontendAccess
- abstract def isCompilingPrimitive: Boolean
True if the current compilation unit is of a primitive class (scala.Boolean et al).
True if the current compilation unit is of a primitive class (scala.Boolean et al). Used only in assertions. Abstract here because its implementation depends on global.
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (BTypes, B)
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cachedClassBType(internalName: InternalName): ClassBType
Every ClassBType is cached on construction and accessible through this method.
Every ClassBType is cached on construction and accessible through this method.
The cache is used when computing stack map frames. The asm.ClassWriter invokes the method
getCommonSuperClass
. In this method we need to obtain the ClassBType for a given internal name. The method assumes that every class type that appears in the bytecode exists in the map - val classBTypeCache: ConcurrentHashMap[InternalName, ClassBType]
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def ensuring(cond: (BTypes) => Boolean, msg: => Any): BTypes
- def ensuring(cond: (BTypes) => Boolean): BTypes
- def ensuring(cond: Boolean, msg: => Any): BTypes
- def ensuring(cond: Boolean): BTypes
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def perRunLazy[T](component: PerRunInit)(init: => T): LazyVar[T]
Create state that lazily evaluated (to work around / not worry about initialization ordering issues).
Create state that lazily evaluated (to work around / not worry about initialization ordering issues). The state is cleared in each compiler run when the component is initialized.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- case object BOOL extends PrimitiveBType with Product with Serializable
- object BType
- object BTypeExporter extends AutoCloseable
- case object BYTE extends PrimitiveBType with Product with Serializable
- case object CHAR extends PrimitiveBType with Product with Serializable
- object ClassBType
- case object DOUBLE extends PrimitiveBType with Product with Serializable
- case object FLOAT extends PrimitiveBType with Product with Serializable
- case object INT extends PrimitiveBType with Product with Serializable
- case object LONG extends PrimitiveBType with Product with Serializable
- object Lazy
- case object SHORT extends PrimitiveBType with Product with Serializable
- case object UNIT extends PrimitiveBType with Product with Serializable
Deprecated Value Members
- def formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from BTypes toStringFormat[BTypes] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.12.16) Use
formatString.format(value)
instead ofvalue.formatted(formatString)
, or use thef""
string interpolator. In Java 15 and later,formatted
resolves to the new method in String which has reversed parameters.
- def →[B](y: B): (BTypes, B)
- Implicit
- This member is added by an implicit conversion from BTypes toArrowAssoc[BTypes] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.
The Scala compiler and reflection APIs.