diff options
author | Miguel Garcia <miguelalfredo.garcia@epfl.ch> | 2013-06-01 22:39:32 +0200 |
---|---|---|
committer | Miguel Garcia <miguelalfredo.garcia@epfl.ch> | 2013-06-01 22:39:32 +0200 |
commit | 22ee2df1a58fbdfe2fa8344e4b6658745bc60d17 (patch) | |
tree | 2dd3e02062cd3b3b373dd9ece7fbccff517044c5 /src/compiler/scala/tools/nsc/transform/CleanUp.scala | |
parent | c4d1217b5a81a74d35b97b62bff270010aedd0dc (diff) | |
download | scala-22ee2df1a58fbdfe2fa8344e4b6658745bc60d17.tar.gz scala-22ee2df1a58fbdfe2fa8344e4b6658745bc60d17.tar.bz2 scala-22ee2df1a58fbdfe2fa8344e4b6658745bc60d17.zip |
new bytecode emitter, GenBCode, for now under a flag
GenBCode is a drop-in replacement for GenASM with several advantages:
- faster: ICode isn't necessary anymore.
Instead, the ASTs delivered by CleanUp (an expression language)
are translated directly into a stack-language (ASM Tree nodes)
- future-proofing for Java 8 (MethodHandles, invokedynamic).
- documentation included, shared mutable state kept to a minimum,
all contributing to making GenBCode more maintainable
than its counterpart (its counterpart being GenICode + GenASM).
A few tests are modified in this commit, for reasons given below.
(1) files/neg/case-collision
Just like GenASM, GenBCode also detects output classfiles
differing only in case. However the error message differs
from that of GenASM (collisions may be show in different order).
Thus the original test now has a flags file containing -neo:GenASM
and a new test (files/neg/case-collision2) has been added
for GenBCode. The .check files in each case show expected output.
(2) files/pos/t5031_3
Currently the test above doesn't work with GenBCode
(try with -neo:GenBCode in the flags file)
The root cause lies in the fix to
https://issues.scala-lang.org/browse/SI-5031
which weakened an assertion in GenASM
(GenBCode keeps the original assertion).
Actually that ticket mentions the fix is a "workaround"
(3) files/run/t7008-scala-defined
This test also passes only under GenASM and not GenBCode,
thus the flags file. GenASM turns a bling eye to:
An AbstractTypeSymbol (SI-7122) has reached the bytecode emitter,
for which no JVM-level internal name can be found:
ScalaClassWithCheckedExceptions_1.E1
The error message above (shown by GenBCode) highlights
there's no ScalaClassWithCheckedExceptions_1.E1 class,
thus shouldn't show up in the emitted bytecode
(GenASM emits bytecode that mentions the inexistent class).
Diffstat (limited to 'src/compiler/scala/tools/nsc/transform/CleanUp.scala')
-rw-r--r-- | src/compiler/scala/tools/nsc/transform/CleanUp.scala | 19 |
1 files changed, 19 insertions, 0 deletions
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index a37ef29355..70ccbca8b4 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -20,6 +20,18 @@ abstract class CleanUp extends Transform with ast.TreeDSL { /** the following two members override abstract members in Transform */ val phaseName: String = "cleanup" + /* used in GenBCode: collects ClassDef symbols owning a main(Array[String]) method */ + private var entryPoints: List[Symbol] = null + def getEntryPoints: List[Symbol] = { + assert(settings.isBCodeActive, "Candidate Java entry points are collected here only when GenBCode in use.") + entryPoints sortBy ("" + _.fullName) // For predictably ordered error messages. + } + + override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = { + entryPoints = if (settings.isBCodeActive) Nil else null; + super.newPhase(prev) + } + protected def newTransformer(unit: CompilationUnit): Transformer = new CleanUpTransformer(unit) @@ -390,6 +402,13 @@ abstract class CleanUp extends Transform with ast.TreeDSL { override def transform(tree: Tree): Tree = tree match { + case _: ClassDef + if (entryPoints != null) && + genBCode.isJavaEntryPoint(tree.symbol, currentUnit) + => + entryPoints ::= tree.symbol + super.transform(tree) + /* Transforms dynamic calls (i.e. calls to methods that are undefined * in the erased type space) to -- dynamically -- unsafe calls using * reflection. This is used for structural sub-typing of refinement |