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
- All
Instance Constructors
- new BTypes()
Type Members
- final case class ArrayBType(componentType: BType) extends RefBType with Product with Serializable
-
sealed
trait
BType extends AnyRef
A BType is either a primitive type, a ClassBType, an ArrayBType of one of these, or a MethodType referring to BTypes.
-
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 re-initializes thoseLazyVar
s that have actually been used in the previous compiler run. - final case class MethodBType(argumentTypes: List[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) 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 trait PrimitiveBType extends BType
- sealed trait 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): Option[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: Map[InternalName, ClassBType]
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- 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: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
- 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 re-initialized 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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- def →[B](y: B): (BTypes, B)
- object BOOL extends PrimitiveBType with Product with Serializable
- object BYTE extends PrimitiveBType with Product with Serializable
- object CHAR extends PrimitiveBType with Product with Serializable
- object ClassBType
- object DOUBLE extends PrimitiveBType with Product with Serializable
- object FLOAT extends PrimitiveBType with Product with Serializable
- object INT extends PrimitiveBType with Product with Serializable
- object LONG extends PrimitiveBType with Product with Serializable
- object Lazy
- object SHORT extends PrimitiveBType with Product with Serializable
- object UNIT extends PrimitiveBType with Product with Serializable
The Scala compiler and reflection APIs.