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.
-
final
case class
ClassBType
(internalName: InternalName) extends RefBType with Product with Serializable
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 (SI-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: List[ClassBType], nestedInfo: 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.
- 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 backendReporting: BackendReporting
- abstract val backendUtils: BackendUtils[BTypes.this.type]
-
abstract
val
byteCodeRepository: ByteCodeRepository[BTypes.this.type]
Tools for parsing classfiles, used by the inliner.
- abstract val callGraph: CallGraph[BTypes.this.type]
- abstract val closureOptimizer: ClosureOptimizer[BTypes.this.type]
- abstract def compilerSettings: ScalaSettings
- abstract val coreBTypes: CoreBTypesProxyGlobalIndependent[BTypes.this.type]
- abstract val inliner: Inliner[BTypes.this.type]
- abstract val inlinerHeuristics: InlinerHeuristics[BTypes.this.type]
-
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.
- abstract val localOpt: LocalOpt[BTypes.this.type]
- abstract def recordPerRunCache[T <: Clearable](cache: T): T
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
Test two objects for inequality.
Test two objects for inequality.
- returns
true
if !(this == that), false otherwise.
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
Equivalent to
x.hashCode
except for boxed numeric types andnull
.Equivalent to
x.hashCode
except for boxed numeric types andnull
. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. Fornull
returns a hashcode wherenull.hashCode
throws aNullPointerException
.- returns
a hash value consistent with ==
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (BTypes, B)
-
final
def
==(arg0: Any): Boolean
The expression
x == that
is equivalent toif (x eq null) that eq null else x.equals(that)
.The expression
x == that
is equivalent toif (x eq null) that eq null else x.equals(that)
.- returns
true
if the receiver object is equivalent to the argument;false
otherwise.
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
Cast the receiver object to be of type
T0
.Cast the receiver object to be of type
T0
.Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression
1.asInstanceOf[String]
will throw aClassCastException
at runtime, while the expressionList(1).asInstanceOf[List[String]]
will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.- returns
the receiver object.
- Definition Classes
- Any
- Exceptions thrown
ClassCastException
if the receiver object is not an instance of the erasure of typeT0
.
-
def
bTypeForDescriptorOrInternalNameFromClassfile(desc: String): BType
Obtain the BType for a type descriptor or internal name.
Obtain the BType for a type descriptor or internal name. For class descriptors, the ClassBType is constructed by parsing the corresponding classfile.
Some JVM operations use either a full descriptor or only an internal name. Example: ANEWARRAY java/lang/String // a new array of strings (internal name for the String class) ANEWARRAY [Ljava/lang/String; // a new array of array of string (full descriptor for the String class)
This method supports both descriptors and internal names.
-
val
callsitePositions: Map[MethodInsnNode, Position]
Store the position of every MethodInsnNode during code generation.
Store the position of every MethodInsnNode during code generation. This allows each callsite in the call graph to remember its source position, which is required for inliner warnings.
-
def
classBTypeFromClassNode(classNode: ClassNode): ClassBType
Construct the ClassBType for a parsed classfile.
-
val
classBTypeFromInternalName: Map[InternalName, ClassBType]
A map from internal names to ClassBTypes.
A map from internal names to ClassBTypes. Every ClassBType is added to this map on its construction.
This map 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.Concurrent because stack map frames are computed when in the class writer, which might run on multiple classes concurrently.
-
def
classBTypeFromParsedClassfile(internalName: InternalName): ClassBType
Parse the classfile for
internalName
and construct the ClassBType.Parse the classfile for
internalName
and construct the ClassBType. If the classfile cannot be found in thebyteCodeRepository
, theinfo
of the resulting ClassBType is undefined. -
def
clone(): AnyRef
Create a copy of the receiver object.
Create a copy of the receiver object.
The default implementation of the
clone
method is platform dependent.- returns
a copy of the receiver object.
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- Note
not specified by SLS as a member of AnyRef
- 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
Tests whether the argument (
that
) is a reference to the receiver object (this
).Tests whether the argument (
that
) is a reference to the receiver object (this
).The
eq
method implements an equivalence relation on non-null instances ofAnyRef
, and has three additional properties:- It is consistent: for any non-null instances
x
andy
of typeAnyRef
, multiple invocations ofx.eq(y)
consistently returnstrue
or consistently returnsfalse
. - For any non-null instance
x
of typeAnyRef
,x.eq(null)
andnull.eq(x)
returnsfalse
. null.eq(null)
returnstrue
.
When overriding the
equals
orhashCode
methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2
), they should be equal to each other (o1 == o2
) and they should hash to the same value (o1.hashCode == o2.hashCode
).- returns
true
if the argument is a reference to the receiver object;false
otherwise.
- Definition Classes
- AnyRef
- It is consistent: for any non-null instances
-
def
equals(arg0: Any): Boolean
The equality method for reference types.
-
def
finalize(): Unit
Called by the garbage collector on the receiver object when there are no more references to the object.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the
finalize
method is invoked, as well as the interaction betweenfinalize
and non-local returns and exceptions, are all platform dependent.- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- Note
not specified by SLS as a member of AnyRef
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
Returns the runtime class representation of the object.
Returns the runtime class representation of the object.
- returns
a class object corresponding to the runtime type of the receiver.
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
The hashCode method for reference types.
-
val
indyLambdaHosts: Set[InternalName]
Classes with indyLambda closure instantiations where the SAM type is serializable (e.g.
Classes with indyLambda closure instantiations where the SAM type is serializable (e.g. Scala's FunctionN) need a
$deserializeLambda$
method. This map contains classes for which such a method has been generated. It is used during ordinary code generation, as well as during inlining: when inlining an indyLambda instruction into a class, we need to make sure the class has the method. -
val
inlineAnnotatedCallsites: Set[MethodInsnNode]
Stores callsite instructions of invocatinos annotated
f(): @inline/noinline
.Stores callsite instructions of invocatinos annotated
f(): @inline/noinline
. Instructions are added during code generation (BCodeBodyBuilder). The maps are then queried when building the CallGraph, every Callsite object has an annotated(No)Inline field. -
def
inlineInfoFromClassfile(classNode: ClassNode): InlineInfo
Build the InlineInfo for a class.
Build the InlineInfo for a class. For Scala classes, the information is stored in the ScalaInlineInfo attribute. If the attribute is missing, the InlineInfo is built using the metadata available in the classfile (ACC_FINAL flags, etc).
-
final
def
isInstanceOf[T0]: Boolean
Test whether the dynamic type of the receiver object is
T0
.Test whether the dynamic type of the receiver object is
T0
.Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression
1.isInstanceOf[String]
will returnfalse
, while the expressionList(1).isInstanceOf[List[String]]
will returntrue
. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.- returns
true
if the receiver object is an instance of erasure of typeT0
;false
otherwise.
- Definition Classes
- Any
-
val
javaDefinedClasses: Set[InternalName]
Contains the internal names of all classes that are defined in Java source files of the current compilation run (mixed compilation).
Contains the internal names of all classes that are defined in Java source files of the current compilation run (mixed compilation). Used for more detailed error reporting.
-
val
maxLocalsMaxStackComputed: Set[MethodNode]
Cache of methods which have correct
maxLocals
/maxStack
values assigned.Cache of methods which have correct
maxLocals
/maxStack
values assigned. This allows invokingcomputeMaxLocalsMaxStack
whenever running an analyzer but performing the actual computation only when necessary. -
final
def
ne(arg0: AnyRef): Boolean
Equivalent to
!(this eq that)
.Equivalent to
!(this eq that)
.- returns
true
if the argument is not a reference to the receiver object;false
otherwise.
- Definition Classes
- AnyRef
- val noInlineAnnotatedCallsites: Set[MethodInsnNode]
-
final
def
notify(): Unit
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.
- Definition Classes
- AnyRef
- Note
not specified by SLS as a member of AnyRef
-
final
def
notifyAll(): Unit
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
- Definition Classes
- AnyRef
- Note
not specified by SLS as a member of AnyRef
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
Creates a String representation of this object.
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
- returns
a String representation of the object.
- Definition Classes
- AnyRef → Any
-
val
unreachableCodeEliminated: Set[MethodNode]
Cache, contains methods whose unreachable instructions are eliminated.
Cache, contains methods whose unreachable instructions are eliminated.
The ASM Analyzer class does not compute any frame information for unreachable instructions. Transformations that use an analyzer (including inlining) therefore require unreachable code to be eliminated.
This cache allows running dead code elimination whenever an analyzer is used. If the method is already optimized, DCE can return early.
-
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
- @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 extends Serializable
- 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 SHORT extends PrimitiveBType with Product with Serializable
- object UNIT extends PrimitiveBType with Product with Serializable
The Scala compiler API.
The following resources are useful for Scala plugin/compiler development: