Inheriting a groovy class

Yes. Compiler crashes are compiler bugs.

On Aug 11, 9:41 pm, Romain wrote:
> Hi Guys,
>
> I get the following exception when I compile a scala class inheriting
> from the org.codehaus.groovy.tools.shell.Command groovy class with the
> latest scala compiler 2.9.1.RC2 and the latest groovy library 1.8.1:
>
>
>
>
>
>
>
>
>
> > [ERROR] error: java.lang.AssertionError: org.codehaus.groovy.tools.shell.Command$1
> > [INFO]     at scala.tools.nsc.symtab.classfile.ClassfileParser$$anonfun$enterOwnInnerClas ses$1.apply(ClassfileParser.scala:1130)
> > [INFO]     at scala.tools.nsc.symtab.classfile.ClassfileParser$$anonfun$enterOwnInnerClas ses$1.apply(ClassfileParser.scala:1127)
> > [INFO]     at scala.collection.mutable.HashMap$$anon$2$$anonfun$foreach$3.apply(HashMap.s cala:102)
> > [INFO]     at scala.collection.mutable.HashMap$$anon$2$$anonfun$foreach$3.apply(HashMap.s cala:102)
> > [INFO]     at scala.collection.Iterator$class.foreach(Iterator.scala:660)
> > [INFO]     at scala.collection.mutable.HashTable$$anon$1.foreach(HashTable.scala:157)
> > [INFO]     at scala.collection.mutable.HashTable$class.foreachEntry(HashTable.scala:190)
> > [INFO]     at scala.collection.mutable.HashMap.foreachEntry(HashMap.scala:43)
> > [INFO]     at scala.collection.mutable.HashMap$$anon$2.foreach(HashMap.scala:102)
> > [INFO]     at scala.tools.nsc.symtab.classfile.ClassfileParser.enterOwnInnerClasses(Class fileParser.scala:1127)
> > [INFO]     at scala.tools.nsc.symtab.classfile.ClassfileParser.parseClass(ClassfileParser .scala:543)
> > [INFO]     at scala.tools.nsc.symtab.classfile.ClassfileParser.parse(ClassfileParser.scal a:99)
> > [INFO]     at scala.tools.nsc.symtab.SymbolLoaders$ClassfileLoader.doComplete(SymbolLoade rs.scala:308)
> > [INFO]     at scala.tools.nsc.symtab.SymbolLoaders$SymbolLoader.complete(SymbolLoaders.sc ala:111)
> > [INFO]     at scala.tools.nsc.symtab.SymbolLoaders$SymbolLoader.load(SymbolLoaders.scala: 130)
> > [INFO]     at scala.tools.nsc.symtab.Symbols$Symbol.exists(Symbols.scala:568)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedIdent$1(Typers.scala:3738)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed1(Typers.scala:4176)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed(Typers.scala:4271)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedType(Typers.scala:4374)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedType(Typers.scala:4377)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer.typeSig(Namers.scala:1212)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$typeCompleter$1.apply(Nam ers.scala:551)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$typeCompleter$1.apply(Nam ers.scala:549)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$$anon$1.complete(Namers.scala:1385)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$$anon$1.complete(Namers.scala:1381)
> > [INFO]     at scala.tools.nsc.symtab.Symbols$Symbol.info(Symbols.scala:727)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$thisMethodType$1$1$$anonf un$apply$19.apply(Namers.scala:876)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$thisMethodType$1$1$$anonf un$apply$19.apply(Namers.scala:876)
> > [INFO]     at scala.collection.LinearSeqOptimized$class.foreach(LinearSeqOptimized.scala: 59)
> > [INFO]     at scala.collection.immutable.List.foreach(List.scala:45)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$thisMethodType$1$1.apply( Namers.scala:876)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$thisMethodType$1$1.apply( Namers.scala:875)
> > [INFO]     at scala.collection.LinearSeqOptimized$class.foreach(LinearSeqOptimized.scala: 59)
> > [INFO]     at scala.collection.immutable.List.foreach(List.scala:45)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer.thisMethodType$1(Namers.scala:875)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer.methodSig(Namers.scala:951)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer.typeSig(Namers.scala:1196)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$typeCompleter$1.apply(Nam ers.scala:551)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$Namer$$anonfun$typeCompleter$1.apply(Nam ers.scala:549)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$$anon$1.complete(Namers.scala:1385)
> > [INFO]     at scala.tools.nsc.typechecker.Namers$$anon$1.complete(Namers.scala:1381)
> > [INFO]     at scala.tools.nsc.symtab.Symbols$Symbol.info(Symbols.scala:727)
> > [INFO]     at scala.tools.nsc.symtab.Symbols$Symbol.initialize(Symbols.scala:839)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed1(Typers.scala:3897)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed(Typers.scala:4271)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedStat$1(Typers.scala:2100)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer$$anonfun$24.apply(Typers.scala:218 4)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer$$anonfun$24.apply(Typers.scala:218 4)
> > [INFO]     at scala.collection.immutable.List.loop$1(List.scala:117)
> > [INFO]     at scala.collection.immutable.List.mapConserve(List.scala:133)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedStats(Typers.scala:2184)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedTemplate(Typers.scala:1512)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedModuleDef(Typers.scala:1320)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed1(Typers.scala:3913)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed(Typers.scala:4271)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedStat$1(Typers.scala:2100)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer$$anonfun$24.apply(Typers.scala:218 4)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer$$anonfun$24.apply(Typers.scala:218 4)
> > [INFO]     at scala.collection.immutable.List.loop$1(List.scala:117)
> > [INFO]     at scala.collection.immutable.List.mapConserve(List.scala:133)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typedStats(Typers.scala:2184)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed1(Typers.scala:3906)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed(Typers.scala:4271)
> > [INFO]     at scala.tools.nsc.typechecker.Typers$Typer.typed(Typers.scala:4331)
> > [INFO]     at scala.tools.nsc.typechecker.Analyzer$typerFactory$$anon$3.apply(Analyzer.sc ala:94)
> > [INFO]     at scala.tools.nsc.Global$GlobalPhase.applyPhase(Global.scala:329)
> > [INFO]     at scala.tools.nsc.typechecker.Analyzer$typerFactory$$anon$3$$anonfun$run$1.ap ply(Analyzer.scala:86)
> > [INFO]     at scala.tools.nsc.typechecker.Analyzer$typerFactory$$anon$3$$anonfun$run$1.ap ply(Analyzer.scala:86)
> > [INFO]     at scala.collection.Iterator$class.foreach(Iterator.scala:660)
> > [INFO]     at scala.collection.mutable.ListBuffer$$anon$1.foreach(ListBuffer.scala:316)
> > [INFO]     at scala.tools.nsc.typechecker.Analyzer$typerFactory$$anon$3.run(Analyzer.scal a:86)
> > [INFO]     at scala.tools.nsc.Global$Run.compileSources(Global.scala:953)
> > [INFO]     at scala.tools.nsc.Global$Run.compile(Global.scala:1038)
> > [INFO]     at scala.tools.nsc.Main$.process(Main.scala:106)
> > [INFO]     at scala.tools.nsc.Main$.main(Main.scala:123)
> > [INFO]     at scala.tools.nsc.Main.main(Main.scala)
> > [INFO]     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
> > [INFO]     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:5 7)
> > [INFO]     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImp l.java:43)
> > [INFO]     at java.lang.reflect.Method.invoke(Method.java:616)
> > [INFO]     at org_scala_tools_maven_executions.MainHelper.runMain(MainHelper.java:161)
> > [INFO]     at org_scala_tools_maven_executions.MainWithArgsInFile.main(MainWithArgsInFile .java:26)
> > [INFO]
>
> With 1.7 groovy version it works. Should I report that as a scala compiler bug ?
>
> Cheers,
> Romain

The underlying issue is that many class files in the groovy jar
mention inner classes that do not exist, for example
org.codehaus.groovy.tools.shell.Command mentions
org.codehaus.groovy.tools.shell.Command$1

The JVM spec says "The Java virtual machine does not currently check
the consistency of the InnerClasses attribute with any class file
actually representing a class or interface referenced by the
attribute."
http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.ht...

The Scala compiler does require the class file to exist. It should
report the error rather than crashing.

A workaround would be to show the Scala compiler a modified groovy jar
that doesn't declare any inner classes that don't exist.

The below Scala program can be used as follows:-

$ scalac TransformGroovyJar.scala

$ scala TransformGroovyJar groovy-1.8.1.jar groovy-1.8.1-clean.jar

$ scalac -classpath groovy-1.8.1-clean.jar Test.scala

At runtime, use the original groovy-1.8.1.jar

import java.io._
import java.util.jar.{JarEntry, JarFile, JarInputStream,
JarOutputStream}

object Definitions {
type u4 = Int
type u2 = Int
type u1 = Int

val CONSTANT_Class = 7
val CONSTANT_Fieldref = 9
val CONSTANT_Methodref = 10
val CONSTANT_InterfaceMethodref = 11
val CONSTANT_String = 8
val CONSTANT_Integer = 3
val CONSTANT_Float = 4
val CONSTANT_Long = 5
val CONSTANT_Double = 6
val CONSTANT_NameAndType = 12
val CONSTANT_Utf8 = 1

def verify(condition: Boolean) {
if (!condition)
throw new ValidationException()
}

def using[A <: { def close() }, B](resource: A)(f: A => B): B = {
try {
f(resource)
} finally {
resource.close()
}
}
}

import Definitions._

class ValidationException extends Exception {}

// an entry in a constant pool
sealed trait CpInfo {
def validate() : Unit
}

class ClassInfo(constantPool: ConstantPool, input : DataInput) extends
CpInfo {
val name_index : u2 = input.readUnsignedShort()

def validate() {
constantPool[Utf8Info](name_index)
}

override def toString() = "ClassInfo("+name_index+"
"+constantPool(name_index)+")"
}

class FieldrefInfo(constantPool: ConstantPool, input : DataInput)
extends CpInfo {
val class_index : u2 = input.readUnsignedShort()
val name_and_type_index : u2 = input.readUnsignedShort()

def validate() {
constantPool[ClassInfo](class_index)
constantPool[NameAndTypeInfo](name_and_type_index)
}

override def toString() = "FieldrefInfo("+class_index+"
"+constantPool(class_index)+", "+name_and_type_index+"
"+constantPool(name_and_type_index)+")"
}

class MethodrefInfo(constantPool: ConstantPool, input : DataInput)
extends CpInfo {
val class_index : u2 = input.readUnsignedShort()
val name_and_type_index : u2 = input.readUnsignedShort()

def validate() {
constantPool[ClassInfo](class_index)
constantPool[NameAndTypeInfo](name_and_type_index)
}

override def toString() = "MethodrefInfo("+class_index+"
"+constantPool(class_index)+", "+name_and_type_index+"
"+constantPool(name_and_type_index)+")"
}

class InterfaceMethodrefInfo(constantPool: ConstantPool, input :
DataInput) extends CpInfo {
val class_index : u2 = input.readUnsignedShort()
val name_and_type_index : u2 = input.readUnsignedShort()

def validate() {
constantPool[ClassInfo](class_index)
constantPool[NameAndTypeInfo](name_and_type_index)
}

override def toString() = "InterfaceMethodrefInfo("+class_index+"
"+constantPool(class_index)+", "+name_and_type_index+"
"+constantPool(name_and_type_index)+")"
}

class StringInfo(constantPool: ConstantPool, input : DataInput)
extends CpInfo {
val string_index : u2 = input.readUnsignedShort()

def validate() {
constantPool[Utf8Info](string_index)
}

override def toString() = "StringInfo("+string_index+"
"+constantPool(string_index)+")"
}

class IntegerInfo(input : DataInput) extends CpInfo {
val value : Int = input.readInt()

def validate() {}

override def toString() = "IntegerInfo("+value+")"
}

class FloatInfo(input : DataInput) extends CpInfo {
val value : Float = input.readFloat()

def validate() {}

override def toString() = "FloatInfo("+value+")"
}

class LongInfo(input : DataInput) extends CpInfo {
val value : Long = input.readLong()

def validate() {}

override def toString() = "LongInfo("+value+")"
}

class DoubleInfo(input : DataInput) extends CpInfo {
val value : Double = input.readDouble()

def validate() {}

override def toString() = "DoubleInfo("+value+")"
}

class NameAndTypeInfo(constantPool: ConstantPool, input : DataInput)
extends CpInfo {
val name_index : u2 = input.readUnsignedShort()
val descriptor_index : u2 = input.readUnsignedShort()

def validate() {
constantPool[Utf8Info](name_index)
constantPool[Utf8Info](descriptor_index)
}

override def toString() = "NameAndTypeInfo("+name_index+"
"+constantPool(name_index)+", "+descriptor_index+"
"+constantPool(descriptor_index)+")"
}

class Utf8Info(input : DataInput) extends CpInfo {
val string : String = input.readUTF()

def validate() {}

override def toString() = string
}

class ConstantPool(input : DataInput) {
private val constant_pool_count : u2 = input.readUnsignedShort()
private val constant_pool = new Array[CpInfo](constant_pool_count)

{
var index = 1
while (index < constant_pool_count) {
constant_pool(index) = readConstant(input)
if (constant_pool(index).isInstanceOf[LongInfo] ||
constant_pool(index).isInstanceOf[DoubleInfo])
index += 1 // 8 byte constants take two constant pool
entries
index += 1
}
}
constant_pool.foreach(constant => if (constant != null)
constant.validate())

def apply[A <: CpInfo : Manifest](index: Int): A = {
verify(0 < index && index < constant_pool_count)
val result = constant_pool(index)
verify(manifest[A].erasure.isInstance(result))
result.asInstanceOf[A]
}

private def readConstant(input : DataInput) : CpInfo = {
val tag : u1 = input.readUnsignedByte()
tag match {
case CONSTANT_Class => new ClassInfo(this, input)
case CONSTANT_Fieldref => new FieldrefInfo(this, input)
case CONSTANT_Methodref => new MethodrefInfo(this, input)
case CONSTANT_InterfaceMethodref => new
InterfaceMethodrefInfo(this, input)
case CONSTANT_String => new StringInfo(this, input)
case CONSTANT_Integer => new IntegerInfo(input)
case CONSTANT_Float => new FloatInfo(input)
case CONSTANT_Long => new LongInfo(input)
case CONSTANT_Double => new DoubleInfo(input)
case CONSTANT_NameAndType => new NameAndTypeInfo(this,
input)
case CONSTANT_Utf8 => new Utf8Info(input)
}
}
}

class ClassFile(input : DataInput, pos: () => Int) {

val magic : u4 = input.readInt()
verify(magic == 0xCAFEBABE)

val minor_version : u2 = input.readUnsignedShort()
val major_version : u2 = input.readUnsignedShort()

val constant_pool = new ConstantPool(input)

val access_flags : u2 = input.readUnsignedShort()
val this_class : u2 = input.readUnsignedShort()
val super_class : u2 = input.readUnsignedShort()

val interfaces_count : u2 = input.readUnsignedShort()
val interfaces : Array[u2] = Array.fill[u2](interfaces_count)
(input.readUnsignedShort())

val fields_count : u2 = input.readUnsignedShort()
val field_info : Array[FieldInfo] = Array.fill[FieldInfo]
(fields_count)(new FieldInfo(constant_pool, input, pos))

val methods_count : u2 = input.readUnsignedShort()
val methods : Array[MethodInfo] = Array.fill[MethodInfo]
(methods_count)(new MethodInfo(constant_pool, input, pos))

val attributes_count : u2 = input.readUnsignedShort()
val attributesOffset = pos()
val attributes : Array[AttributeInfo] = Array.fill[AttributeInfo]
(attributes_count)(new AttributeInfo(constant_pool, input, pos))
}

class FieldInfo(constantPool: ConstantPool, input : DataInput, pos: ()
=> Int) {

val access_flags : u2 = input.readUnsignedShort()

val name_index : u2 = input.readUnsignedShort()
constantPool[Utf8Info](name_index)

val descriptor_index : u2 = input.readUnsignedShort()
constantPool[Utf8Info](descriptor_index)

val attributes_count : u2 = input.readUnsignedShort()
val attributes : Array[AttributeInfo] = Array.fill[AttributeInfo]
(attributes_count)(new AttributeInfo(constantPool, input, pos))
}

class MethodInfo(constantPool: ConstantPool, input : DataInput, pos:
() => Int) {
val access_flags : u2 = input.readUnsignedShort()

val name_index : u2 = input.readUnsignedShort()
constantPool[Utf8Info](name_index)

val descriptor_index : u2 = input.readUnsignedShort()
constantPool[Utf8Info](descriptor_index)

val attributes_count : u2 = input.readUnsignedShort()
val attributes : Array[AttributeInfo] = Array.fill[AttributeInfo]
(attributes_count)(new AttributeInfo(constantPool, input, pos))
}

class AttributeInfo(constantPool: ConstantPool, input : DataInput,
pos: () => Int) {
val offset = pos()

val attribute_name_index : u2 = input.readUnsignedShort()
constantPool[Utf8Info](attribute_name_index)

val attribute_length : u4 = input.readInt()
val info = Array.ofDim[Byte](attribute_length)
input.readFully(info)

val entries : Option[Array[ClassArrayEntry]] = if
(constantPool[Utf8Info](attribute_name_index).string ==
"InnerClasses") {
val attributeInput = new DataInputStream(new
ByteArrayInputStream(info))

val number_of_classes : u2 =
attributeInput.readUnsignedShort()
verify(attribute_length == 2 + 8 * number_of_classes)

Some(Array.fill[ClassArrayEntry](number_of_classes)(new
ClassArrayEntry(constantPool, attributeInput)))
} else {
None
}
}

class ClassArrayEntry(constantPool : ConstantPool, input : DataInput)
{

val inner_class_info_index : u2 = input.readUnsignedShort()
if (inner_class_info_index != 0) {
constantPool[ClassInfo](inner_class_info_index)
}

val outer_class_info_index : u2 = input.readUnsignedShort()
if (outer_class_info_index != 0) {
constantPool[ClassInfo](outer_class_info_index)
}

val inner_name_index : u2 = input.readUnsignedShort()
if (inner_name_index != 0) {
constantPool[Utf8Info](inner_name_index)
}

val inner_class_access_flags : u2 = input.readUnsignedShort()

override def toString() = (
"ClassArrayEntry("+
inner_class_info_index+"
"+optionalDescription(inner_class_info_index)+", "+
outer_class_info_index+"
"+optionalDescription(outer_class_info_index)+", "+
inner_name_index+" "+optionalDescription(inner_name_index)+",
"+
"0x"+Integer.toHexString(inner_class_access_flags)+")"
)

private def optionalDescription(index: Int): String = if (index ==
0) "" else constantPool(index).toString

}

object TransformGroovyJar {

// remove any references to inner classes that do not exist
def transformClass(entryNames: Set[String], jarEntry: JarEntry,
data: Array[Byte]): Array[Byte] = {
val byteArrayInputStream = new ByteArrayInputStream(data)
val byteArrayOutputStream = new
ByteArrayOutputStream(data.length)
def pos(): Int = data.length -
byteArrayInputStream.available()
val classFile = new ClassFile(new
DataInputStream(byteArrayInputStream), pos)

// all data before the various AttributeInfo
byteArrayOutputStream.write(data, 0,
classFile.attributesOffset)
var offset = classFile.attributesOffset
for (attributeInfo <- classFile.attributes) {
verify(offset == attributeInfo.offset)
val size = 2 + 4 + attributeInfo.attribute_length
if (attributeInfo.entries.isEmpty) {
// attribute is not InnerClasses
byteArrayOutputStream.write(data, offset, size)
} else {
val entries = attributeInfo.entries.get

// attribute is InnerClasses
val constantPool = classFile.constant_pool

def classExists(classInfoIndex: Int): Boolean = {
val nameIndex = constantPool[ClassInfo]
(classInfoIndex).name_index
val name = constantPool[Utf8Info]
(nameIndex).string
entryNames.contains(name)
}

val validInnerClasses: Array[Boolean] =
entries.map(entry => classExists(entry.inner_class_info_index))
val numValidInnerClasses: Int =
validInnerClasses.count(_ == true)

val attributeDataLength = 2 + 4 + 2 + 8 *
numValidInnerClasses
val attributeDataByteArrayOutputStream = new
ByteArrayOutputStream(attributeDataLength)
val dataOutputStream = new
DataOutputStream(attributeDataByteArrayOutputStream)

dataOutputStream.writeShort(attributeInfo.attribute_name_index)
dataOutputStream.writeInt(2 + 8 *
numValidInnerClasses)
dataOutputStream.writeShort(numValidInnerClasses)
for ((entry, index) <- entries.zipWithIndex) {
if (validInnerClasses(index)) {

dataOutputStream.writeShort(entry.inner_class_info_index)

dataOutputStream.writeShort(entry.outer_class_info_index)

dataOutputStream.writeShort(entry.inner_name_index)

dataOutputStream.writeShort(entry.inner_class_access_flags)
}
}
verify(attributeDataByteArrayOutputStream.size() ==
attributeDataLength)
val attributeData =
attributeDataByteArrayOutputStream.toByteArray()
// sanity check
new AttributeInfo(constantPool, new
DataInputStream(new ByteArrayInputStream(attributeData)), () => 0)

byteArrayOutputStream.write(attributeData, 0,
attributeData.length)
}
offset += size
}
verify(offset == data.length)

byteArrayOutputStream.toByteArray
}

def readCurrentJarEntry(jarInputStream: JarInputStream,
uncompressedSize: Int) = {
val data = new Array[Byte](uncompressedSize)

var offset = 0
var chunkSize = jarInputStream.read(data, offset,
uncompressedSize - offset)
while (0 < chunkSize) {
offset += chunkSize

chunkSize = jarInputStream.read(data, offset,
uncompressedSize - offset)
}

verify(offset == uncompressedSize)

data
}

def transformFile(entryNames: Set[String], jarInputStream:
JarInputStream, jarEntry: JarEntry, uncompressedSize: Long,
jarOutputStream: JarOutputStream) {
if (jarEntry.getSize == -1) {
jarEntry.setSize(uncompressedSize)
} else {
verify(jarEntry.getSize == uncompressedSize)
}
if (jarEntry.getName.endsWith(".class")) {
verify(uncompressedSize == uncompressedSize.toInt)
val inputData: Array[Byte] =
readCurrentJarEntry(jarInputStream, uncompressedSize.toInt)
val outputData: Array[Byte] = transformClass(entryNames,
jarEntry, inputData)
if (inputData.length == outputData.length) {
verify(java.util.Arrays.equals(inputData, outputData))
} else {
println(jarEntry.getName)
val outputData2: Array[Byte] =
transformClass(entryNames, jarEntry, outputData)
verify(java.util.Arrays.equals(outputData,
outputData2))
}
val updatedJarEntry =
jarEntry.clone().asInstanceOf[JarEntry]
updatedJarEntry.setSize(outputData.length)
updatedJarEntry.setCompressedSize(-1) // unknown
jarOutputStream.putNextEntry(updatedJarEntry)
jarOutputStream.write(outputData, 0, outputData.length)
} else {
// copy data without processing
jarOutputStream.putNextEntry(jarEntry)
val buffer = new Array[Byte](4096)
var chunkSize = jarInputStream.read(buffer)
while (0 < chunkSize) {
jarOutputStream.write(buffer, 0, chunkSize)
chunkSize = jarInputStream.read(buffer)
}
}
jarOutputStream.closeEntry()
}

def createJarOutputStream(outputStream: OutputStream, manifest:
java.util.jar.Manifest): JarOutputStream = {
if (manifest == null)
new JarOutputStream(outputStream)
else
new JarOutputStream(outputStream, manifest)
}

def transformJar(sourcePath: String, destinationPath: String) {
import
scala.collection.JavaConversions.enumerationAsScalaIterator
val sizeTable: Map[String, Long] = using(new
JarFile(sourcePath)) { jarFile =>
Map(jarFile.entries().toStream.map(jarEntry =>
(jarEntry.getName, jarEntry.getSize)) : _*)
}
val entryNames = sizeTable.keySet

using(new JarInputStream(new BufferedInputStream(new
FileInputStream(sourcePath)))) { jarInputStream =>
val manifest = jarInputStream.getManifest()
using(createJarOutputStream(new BufferedOutputStream(new
FileOutputStream(destinationPath)), manifest)) { jarOutputStream =>
var jarEntry = jarInputStream.getNextJarEntry()
while (jarEntry != null) {
transformFile(entryNames, jarInputStream,
jarEntry, sizeTable(jarEntry.getName), jarOutputStream)
jarEntry = jarInputStream.getNextJarEntry()
}
jarOutputStream.finish()
}
}
}

def main(args: Array[String]) {
if (args.length != 2) {
println("usage: scala TransformGroovyJar
")
sys.exit(1)
}

transformJar(args(0), args(1))
}
}