==== Patch <janino-optimize> level 1
Source: 737f8f2c-97f8-0310-ac9b-cfac8cc1a2f5:/eng/third-party/janino/newbury-optimized:74317
        (svn+ssh://svn.streambase.com/repos/sb)
Target: 737f8f2c-97f8-0310-ac9b-cfac8cc1a2f5:/eng/third-party/janino/trunk:74183
        (svn+ssh://svn.streambase.com/repos/sb)
Log:
 r76154@spiceweasel (orig r74313):  fowles | 2008-06-17 13:53:49 -0400
 creating a branch for newbury that contains our optimizations
 

=== tests/src/UnparseTests.java
==================================================================
--- tests/src/UnparseTests.java	(revision 74183)
+++ tests/src/UnparseTests.java	(patch janino-optimize level 1)
@@ -299,7 +299,6 @@
                     UnparseTests.stripUnnecessaryParenExprs(aae.index)
                 );
             }
-
             public void visitFieldAccess(FieldAccess fa) {
                 res[0] = new Java.FieldAccess(
                     fa.getLocation(),
@@ -399,7 +398,7 @@
             UnparseTests.helpTestExpr(input, expectNoSimplify, false);
         }
     }
-    
+
     public void testLiterals() throws Exception {
         Object[][] tests = new Object[][] {
                 { new Java.Literal(null, new Short((short)1)), "((short)1)" },
@@ -457,7 +456,6 @@
                             String s1 = locatable1.toString();
                             String s2 = locatable2.toString();
                             if (!s1.equals(s2)) {
-//                                String s = new String(ba);
                                 Assert.fail(locatable1.getLocation().toString() + ": Expected \"" + s1 + "\", was \"" + s2 + "\"");
                             }
                         }
@@ -477,7 +475,6 @@
                 new Traverser() {
 
                     // Two implementations of "Locatable": "Located" and "AbstractTypeDeclaration".
-
                     public void traverseLocated(Located l) {
                         locatables.add(l);
                         super.traverseLocated(l);
=== tests/src/EvaluatorTests.java
==================================================================
--- tests/src/EvaluatorTests.java	(revision 74183)
+++ tests/src/EvaluatorTests.java	(patch janino-optimize level 1)
@@ -74,6 +74,7 @@
 //        s.addTest(new EvaluatorTests("testStaticInitAccessProtected"));
         s.addTest(new EvaluatorTests("testDivByZero"));
         s.addTest(new EvaluatorTests("test32kBranchLimit"));
+        s.addTest(new EvaluatorTests("test32kConstantPool"));
         s.addTest(new EvaluatorTests("testHugeIntArray"));
         return s;
     }
@@ -495,64 +496,63 @@
         }
         
     }
-    
-    
-    public void testHugeIntArray() throws Exception {
+    public void test32kConstantPool() throws Exception {
         String preamble =
             "package test;\n" +
-            "public class Test {\n" +
-            "    public int[] run() {\n" +
-            "        return 1.0 > 2.0 ? null : new int[] {";
-        String middle = " 123,";
-        String postamble = 
-            "        };\n" +
-            "    }\n" +
+            "public class Test {\n";
+        String postamble =
             "}";
         
-        int[] tests = new int[] { 1, 10, 8192};
+        
+        int[] tests = new int[] { 1, 100, 13020 };
         for(int i = 0; i < tests.length; ++i) {
             int repititions = tests[i];
             
             StringBuffer sb = new StringBuffer();
-            StringBuffer expected = new StringBuffer();
             sb.append(preamble);
             for(int j = 0; j < repititions; ++j) {
-                sb.append(middle);
-                expected.append(middle);
+                sb.append("boolean _v").append(Integer.toString(j)).append(" = false;\n");
             }
             sb.append(postamble);
             
             SimpleCompiler sc = new SimpleCompiler();
             sc.cook(sb.toString());
+            
+            Class c = sc.getClassLoader().loadClass("test.Test");
+            Object o = c.newInstance();
+            assertNotNull(o);
         }
-        
     }
     
-    public void test32kConstantPool() throws Exception {
+    
+    public void testHugeIntArray() throws Exception {
         String preamble =
             "package test;\n" +
-            "public class Test {\n";
-        String postamble =
+            "public class Test {\n" +
+            "    public int[] run() {\n" +
+            "        return 1.0 > 2.0 ? null : new int[] {";
+        String middle = " 123,";
+        String postamble = 
+            "        };\n" +
+            "    }\n" +
             "}";
         
-        
-        int[] tests = new int[] { 1, 100, 13020 };
+        int[] tests = new int[] { 1, 10, 8192};
         for(int i = 0; i < tests.length; ++i) {
             int repititions = tests[i];
             
-            StringBuffer sb = new StringBuffer();
+            StringBuilder sb = new StringBuilder();
+            StringBuilder expected = new StringBuilder();
             sb.append(preamble);
             for(int j = 0; j < repititions; ++j) {
-                sb.append("boolean _v").append(Integer.toString(j)).append(" = false;\n");
+                sb.append(middle);
+                expected.append(middle);
             }
             sb.append(postamble);
             
             SimpleCompiler sc = new SimpleCompiler();
             sc.cook(sb.toString());
-            
-            Class c = sc.getClassLoader().loadClass("test.Test");
-            Object o = c.newInstance();
-            assertNotNull(o);
         }
+        
     }
 }
=== tests/src/AstTests.java
==================================================================
--- tests/src/AstTests.java	(revision 74183)
+++ tests/src/AstTests.java	(patch janino-optimize level 1)
@@ -0,0 +1,361 @@
+
+/*
+ * Janino - An embedded Java[TM] compiler
+ *
+ * Copyright (c) 2001-2007, Arno Unkrig
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *    3. The name of the author may not be used to endorse or promote
+ *       products derived from this software without specific prior
+ *       written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.codehaus.janino.CompileException;
+import org.codehaus.janino.Java;
+import org.codehaus.janino.Location;
+import org.codehaus.janino.Mod;
+import org.codehaus.janino.SimpleCompiler;
+import org.codehaus.janino.UnparseVisitor;
+import org.codehaus.janino.Java.AmbiguousName;
+import org.codehaus.janino.Java.ArrayType;
+import org.codehaus.janino.Java.BasicType;
+import org.codehaus.janino.Java.Block;
+import org.codehaus.janino.Java.CompilationUnit;
+import org.codehaus.janino.Java.ExpressionStatement;
+import org.codehaus.janino.Java.Literal;
+import org.codehaus.janino.Java.LocalVariableDeclarationStatement;
+import org.codehaus.janino.Java.MethodDeclarator;
+import org.codehaus.janino.Java.PackageMemberClassDeclaration;
+import org.codehaus.janino.Java.ReturnStatement;
+import org.codehaus.janino.Java.Rvalue;
+import org.codehaus.janino.Java.Type;
+import org.codehaus.janino.Java.FunctionDeclarator.FormalParameter;
+import org.codehaus.janino.Parser.ParseException;
+import org.codehaus.janino.Scanner.ScanException;
+
+public class AstTests extends TestCase {
+    public static Test suite() {
+        TestSuite s = new TestSuite(AstTests.class.getName());
+        s.addTest(new AstTests("testSimpleAst"));
+        s.addTest(new AstTests("testLocalVariable"));
+        s.addTest(new AstTests("testBlock"));
+        s.addTest(new AstTests("testByteArrayLiteral"));
+        s.addTest(new AstTests("testClassRef"));
+        s.addTest(new AstTests("testPrecedence"));
+        return s;
+    }
+    
+    public AstTests(String name) { super(name); }
+
+    private static Object compileAndEval(CompilationUnit cu) throws CompileException,
+            ParseException, ScanException, IOException, ClassNotFoundException,
+            InstantiationException, IllegalAccessException,
+            NoSuchMethodException, InvocationTargetException {
+        SimpleCompiler compiler = new SimpleCompiler();
+        compiler.cook(cu);
+        
+        ClassLoader loader = compiler.getClassLoader(); 
+        
+        Class handMadeClass = loader.loadClass("HandMade");
+        
+        Object handMade = handMadeClass.newInstance();
+        Method calc = handMadeClass.getMethod("calculate", null);
+        Object res = calc.invoke(handMade, null);
+        return res;
+    }
+    
+    private static ArrayType createByteArrayType() {
+        return new Java.ArrayType(
+                new Java.BasicType(
+                        getLocation(), 
+                        Java.BasicType.BYTE
+                )
+        );
+    };
+    
+    private static PackageMemberClassDeclaration createClass(CompilationUnit cu)
+            throws ParseException {
+        PackageMemberClassDeclaration clazz = new PackageMemberClassDeclaration(
+                getLocation(),
+                null,
+                Mod.PUBLIC,
+                "HandMade",
+                null,
+                new Type[]{}
+        );
+        cu.addPackageMemberTypeDeclaration(clazz);
+        return clazz;
+    }
+    
+    private static Type createDoubleType() {
+        return new BasicType(getLocation(), BasicType.DOUBLE);
+    }
+    
+    private static Java.BinaryOperation createOp(Rvalue l1, String op, Rvalue l2) {
+        return new Java.BinaryOperation(getLocation(), l1, op, l2);
+    }
+    
+    private static Literal createLiteral(double d) {
+        return createLiteral(Double.valueOf(d));
+    }
+    
+    
+    private static Literal createLiteral(Object o) {
+        return new Literal( getLocation(), o );
+    }
+    
+    private static void createMethod(PackageMemberClassDeclaration clazz, Block body, Type returnType) {
+        MethodDeclarator method = new MethodDeclarator(
+                getLocation(),
+                null,
+                (short)(Mod.PUBLIC),
+                returnType,
+                "calculate",
+                new FormalParameter[0],
+                new Type[0],
+                body
+        );
+        clazz.addDeclaredMethod(method);
+    }
+        
+
+    private static LocalVariableDeclarationStatement createVarDecl(String name, double value) {
+        return new Java.LocalVariableDeclarationStatement(
+                getLocation(),
+                (short)0,
+                createDoubleType(),
+                new Java.VariableDeclarator[] {
+                    new Java.VariableDeclarator(
+                            getLocation(),
+                            name,
+                            0,
+                            createLiteral(value)
+                    )
+                }
+        );
+    }
+    
+    private static AmbiguousName createVariableRef(String name) {
+        return new Java.AmbiguousName(
+                getLocation(),
+                new String[] { name }
+        );
+    }
+
+    /**
+     * "Clever" method to get a location from a stack trace
+     */
+    static private Location getLocation() {
+        Exception e = new Exception();
+        StackTraceElement ste = e.getStackTrace()[1];//we only care about our caller
+        return new Location( 
+                ste.getFileName(), 
+                (short)ste.getLineNumber(), 
+                (short)0
+        );
+    }
+
+    
+    public void testBlock() throws Exception {
+        CompilationUnit cu = new CompilationUnit("AstTests.java");
+        
+        PackageMemberClassDeclaration clazz = createClass(cu);
+        
+        Block body = new Block(getLocation());
+        
+        Block sub = new Block(getLocation());
+        sub.addStatement( createVarDecl("x", 2.0) );                         
+        
+        body.addStatement(sub);
+        body.addStatement(
+                new ReturnStatement(
+                        getLocation(),
+                        new Java.BinaryOperation(
+                                getLocation(),
+                                createVariableRef("x"),
+                                "*",
+                                createLiteral(3)
+                        )
+                )
+        );
+        
+        createMethod(clazz, body, createDoubleType());
+        
+        try {
+            compileAndEval(cu);
+            fail("Block must limit the scope of variables in it");
+        } catch(CompileException ex) {
+            assertTrue(ex.getMessage().endsWith("Expression \"x\" is not an rvalue"));
+        }
+    }
+
+    public void testByteArrayLiteral() throws Exception {
+        CompilationUnit cu = new CompilationUnit("AstTests.java");
+        
+        PackageMemberClassDeclaration clazz = createClass(cu);
+        
+        Byte exp = Byte.valueOf((byte)1);
+        Block body = new Block(getLocation());
+        body.addStatement(
+                new ReturnStatement(
+                        getLocation(),
+                        new Java.NewInitializedArray(
+                                getLocation(),
+                                createByteArrayType(),
+                                new Java.ArrayInitializer(
+                                        getLocation(),
+                                        new Java.Rvalue[] {
+                                            createLiteral(exp)
+                                        }
+                                )
+                        )
+                )
+        );
+        
+        createMethod(clazz, body, 
+                createByteArrayType()
+        );
+        
+        Object res = compileAndEval(cu);
+        assertEquals(exp.byteValue(), ((byte[])res)[0]);
+    }
+
+    public void testLocalVariable() throws Exception {
+        CompilationUnit cu = new CompilationUnit("AstTests.java");
+        
+        PackageMemberClassDeclaration clazz = createClass(cu);
+        
+        Block body = new Block(getLocation());
+        body.addStatement( createVarDecl("x", 2.0) );                         
+        body.addStatement(
+                new ReturnStatement(
+                        getLocation(),
+                        new Java.BinaryOperation(
+                                getLocation(),
+                                createVariableRef("x"),
+                                "*",
+                                createLiteral(3)
+                        )
+                )
+        );
+        
+        createMethod(clazz, body, createDoubleType());
+        
+        Object res = compileAndEval(cu);
+        assertTrue(res instanceof Double);
+        assertEquals(Double.valueOf(6.0), res);
+    }
+    
+    public void testSimpleAst() throws Exception {
+        CompilationUnit cu = new CompilationUnit("AstTests.java");
+        
+        PackageMemberClassDeclaration clazz = createClass(cu);
+        
+        Block body = new Block(getLocation());
+        body.addStatement(
+                new ReturnStatement(
+                        getLocation(),
+                        createLiteral(3.0)
+                )
+        );
+        
+        createMethod(clazz, body, createDoubleType());
+        
+        Object res = compileAndEval(cu);
+        assertEquals(Double.valueOf(3.0), res);
+    }
+
+    public void testClassRef() throws Exception {
+        CompilationUnit cu = new CompilationUnit("AstTests.java");
+        
+        PackageMemberClassDeclaration clazz = createClass(cu);
+        
+        Block body = new Block(getLocation());
+        
+        body.addStatement(
+                new ReturnStatement(
+                        getLocation(),
+                        new Java.ClassLiteral(
+                                getLocation(),
+                                new Java.ReferenceType(
+                                        getLocation(),
+                                        new String[] {
+                                            "HandMade"
+                                        }
+                                )
+                        )
+                )
+        );
+        
+        createMethod(clazz, body, 
+                new Java.ReferenceType(
+                        getLocation(),
+                        new String[] { "java", "lang", "Class" }
+                )
+        );
+        
+        SimpleCompiler compiler = new SimpleCompiler();
+        compiler.cook(cu);
+        
+        ClassLoader loader = compiler.getClassLoader(); 
+        Class handMadeClass = loader.loadClass("HandMade");
+        Method calc = handMadeClass.getMethod("calculate", null);
+        
+        Object handMade = handMadeClass.newInstance();
+        Object res = calc.invoke(handMade, null);
+        assertEquals(handMadeClass, res);
+    }
+    
+    public void testPrecedence() throws Exception {
+        ExpressionStatement es = new Java.ExpressionStatement(
+                new Java.Assignment(
+                        getLocation(),
+                        new Java.AmbiguousName(
+                                getLocation(),
+                                new String[] { "x" }
+                        ),
+                        "=",
+                        createOp(
+                                createLiteral(1), "*",
+                                createOp(createLiteral(2), "+", createLiteral(3))
+                        )
+                )
+        );
+        
+        StringWriter sw = new StringWriter();
+        UnparseVisitor uv = new UnparseVisitor(sw);
+        uv.visitExpressionStatement(es);
+        assertEquals("x = 1.0D * ((( 2.0D + 3.0D )));", sw.toString());
+    }
+}
=== tests/src/AllTests.java
==================================================================
--- tests/src/AllTests.java	(revision 74183)
+++ tests/src/AllTests.java	(patch janino-optimize level 1)
@@ -82,6 +82,7 @@
         this.addTest(ReportedBugs.suite());
         this.addTest(SandboxTests.suite());
         this.addTest(EvaluatorTests.suite());
+        this.addTest(AstTests.suite());
         this.addTest(UnparseTests.suite());
     }
 }
=== src/org/codehaus/janino/UnitCompiler.java
==================================================================
--- src/org/codehaus/janino/UnitCompiler.java	(revision 74183)
+++ src/org/codehaus/janino/UnitCompiler.java	(patch janino-optimize level 1)
@@ -34,15 +34,67 @@
 
 package org.codehaus.janino;
 
-import java.io.*;
-import java.util.*;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
 
-import org.codehaus.janino.IClass.*;
-import org.codehaus.janino.Java.*;
-import org.codehaus.janino.Java.CompilationUnit.*;
-import org.codehaus.janino.Visitor.*;
-import org.codehaus.janino.util.*;
-import org.codehaus.janino.util.enumerator.*;
+import org.codehaus.janino.IClass.IField;
+import org.codehaus.janino.IClass.IInvocable;
+import org.codehaus.janino.IClass.IMethod;
+import org.codehaus.janino.Java.AlternateConstructorInvocation;
+import org.codehaus.janino.Java.Block;
+import org.codehaus.janino.Java.BlockStatement;
+import org.codehaus.janino.Java.BreakStatement;
+import org.codehaus.janino.Java.CatchClause;
+import org.codehaus.janino.Java.ConstructorDeclarator;
+import org.codehaus.janino.Java.ConstructorInvocation;
+import org.codehaus.janino.Java.ContinueStatement;
+import org.codehaus.janino.Java.DoStatement;
+import org.codehaus.janino.Java.EmptyStatement;
+import org.codehaus.janino.Java.ExpressionStatement;
+import org.codehaus.janino.Java.FieldAccess;
+import org.codehaus.janino.Java.FieldDeclaration;
+import org.codehaus.janino.Java.ForStatement;
+import org.codehaus.janino.Java.FunctionDeclarator;
+import org.codehaus.janino.Java.IfStatement;
+import org.codehaus.janino.Java.Initializer;
+import org.codehaus.janino.Java.Invocation;
+import org.codehaus.janino.Java.LabeledStatement;
+import org.codehaus.janino.Java.LocalClassDeclarationStatement;
+import org.codehaus.janino.Java.LocalVariable;
+import org.codehaus.janino.Java.LocalVariableDeclarationStatement;
+import org.codehaus.janino.Java.Locatable;
+import org.codehaus.janino.Java.ReturnStatement;
+import org.codehaus.janino.Java.Rvalue;
+import org.codehaus.janino.Java.SimpleType;
+import org.codehaus.janino.Java.Statement;
+import org.codehaus.janino.Java.SuperConstructorInvocation;
+import org.codehaus.janino.Java.SuperclassFieldAccessExpression;
+import org.codehaus.janino.Java.SwitchStatement;
+import org.codehaus.janino.Java.SynchronizedStatement;
+import org.codehaus.janino.Java.ThrowStatement;
+import org.codehaus.janino.Java.TryStatement;
+import org.codehaus.janino.Java.WhileStatement;
+import org.codehaus.janino.Java.CompilationUnit.ImportDeclaration;
+import org.codehaus.janino.Java.CompilationUnit.SingleStaticImportDeclaration;
+import org.codehaus.janino.Java.CompilationUnit.SingleTypeImportDeclaration;
+import org.codehaus.janino.Java.CompilationUnit.StaticImportOnDemandDeclaration;
+import org.codehaus.janino.Java.CompilationUnit.TypeImportOnDemandDeclaration;
+import org.codehaus.janino.Visitor.BlockStatementVisitor;
+import org.codehaus.janino.Visitor.ImportVisitor;
+import org.codehaus.janino.util.ClassFile;
+import org.codehaus.janino.util.enumerator.EnumeratorSet;
 
 /**
  * This class actually implements the Java<sup>TM</sup> compiler. It is
@@ -346,10 +398,10 @@
                 if (tbd.isStatic()) b.addButDontEncloseStatement((Java.BlockStatement) tbd);
             }
 
-            maybeCreateInitMethod(cd, cf, b);
+            this.maybeCreateInitMethod(cd, cf, b);
         }
 
-        compileDeclaredMethods(cd, cf);
+        this.compileDeclaredMethods(cd, cf);
 
         
         // Compile declared constructors.
@@ -366,8 +418,12 @@
             }
         }
 
+        // A side effect of this call may create synthetic functions to access
+        // protected parent variables
+        this.compileDeclaredMemberTypes(cd, cf);
+
         // Compile the aforementioned extras.
-        compileDeclaredMethods(cd, cf, declaredMethodCount);
+        this.compileDeclaredMethods(cd, cf, declaredMethodCount);
 
         // Class and instance variables.
         for (Iterator it = cd.variableDeclaratorsAndInitializers.iterator(); it.hasNext();) {
@@ -387,7 +443,6 @@
             );
         }
 
-        compileDeclaredMemberTypes(cd, cf);
 
         // Add the generated class file to a thread-local store.
         this.generatedClassFiles.add(cf);
@@ -669,7 +724,7 @@
             boolean previousStatementCanCompleteNormally = true;
             for (int i = 0; i < b.statements.size(); ++i) {
                 Java.BlockStatement bs = (Java.BlockStatement) b.statements.get(i);
-                if (!previousStatementCanCompleteNormally) {
+                if (!previousStatementCanCompleteNormally && this.generatesCode(bs)) {
                     this.compileError("Statement is unreachable", bs.getLocation());
                     break;
                 }
@@ -1246,7 +1301,7 @@
             if (s instanceof Java.BlockStatement && es instanceof Java.Block) {
                 Java.BlockStatement bs = (Java.BlockStatement) s;
                 Java.Block          b = (Java.Block) es;
-                for (Iterator it = b.statements.iterator();;) {
+                for (Iterator it = b.statements.iterator(); it.hasNext();) {
                     Java.BlockStatement bs2 = (Java.BlockStatement) it.next();
                     if (bs2 instanceof Java.LocalClassDeclarationStatement) {
                         Java.LocalClassDeclarationStatement lcds = ((Java.LocalClassDeclarationStatement) bs2);
@@ -1267,10 +1322,6 @@
             Java.VariableDeclarator vd = lvds.variableDeclarators[j];
 
             Java.LocalVariable lv = this.getLocalVariable(lvds, vd);
-
-            // Check for local variable redefinition.
-            if (this.findLocalVariable((Java.BlockStatement) lvds, vd.name) != lv) this.compileError("Redefinition of local variable \"" + vd.name + "\" ", vd.getLocation());
-            
             lv.localVariableArrayIndex = this.codeContext.allocateLocalVariable(Descriptor.size(lv.type.getDescriptor()));
 
             if (vd.optionalInitializer != null) {
@@ -1617,15 +1668,7 @@
                 }
             }
 
-            // Add function parameters.
-            Set usedParameterNames = new HashSet();
-            for (int i = 0; i < fd.formalParameters.length; ++i) {
-                Java.FunctionDeclarator.FormalParameter fp = fd.formalParameters[i];
-                if (usedParameterNames.contains(fp.name)) this.compileError("Redefinition of formal parameter \"" + fp.name + "\"", fd.getLocation());
-                Java.LocalVariable lv = UnitCompiler.this.getLocalVariable(fp);
-                lv.localVariableArrayIndex = this.codeContext.allocateLocalVariable(Descriptor.size(lv.type.getDescriptor()));
-                usedParameterNames.add(fp.name);
-            }
+            this.buildLocalVariableMap(fd);
 
             // Compile the constructor preamble.
             if (fd instanceof Java.ConstructorDeclarator) {
@@ -1672,6 +1715,9 @@
 
             // Compile the function body.
             try {
+                if(fd.optionalBody == null) {
+                    this.compileError("Method must have a body", fd.getLocation());
+                }
                 boolean canCompleteNormally = this.compile(fd.optionalBody);
                 if (canCompleteNormally) {
                     if (this.getReturnType(fd) != IClass.VOID) this.compileError("Method must return a value", fd.getLocation());
@@ -1691,6 +1737,7 @@
         // Don't continue code attribute generation if we had compile errors.
         if (this.compileErrorCount > 0) return;
 
+        // fix up and reallocate as needed
         codeContext.fixUpAndRelocate();
 
         // Do flow analysis.
@@ -1718,6 +1765,153 @@
         });
     }
 
+    private void buildLocalVariableMap(FunctionDeclarator fd) throws CompileException {
+        Map localVars = new HashMap();
+        // Add function parameters.
+        for (int i = 0; i < fd.formalParameters.length; ++i) {
+            Java.FunctionDeclarator.FormalParameter fp = fd.formalParameters[i];
+            if (localVars.containsKey(fp.name)) this.compileError("Redefinition of formal parameter \"" + fp.name + "\"", fd.getLocation());
+            Java.LocalVariable lv = this.getLocalVariable(fp);
+            lv.localVariableArrayIndex = this.codeContext.allocateLocalVariable(Descriptor.size(lv.type.getDescriptor()));
+            
+            localVars.put(fp.name, lv);
+        }
+        
+        fd.localVariables = localVars;
+        if (fd instanceof ConstructorDeclarator) {
+            ConstructorDeclarator cd = (ConstructorDeclarator) fd;
+            if(cd.optionalConstructorInvocation != null) {
+                buildLocalVariableMap(cd.optionalConstructorInvocation, localVars);
+            }
+        }
+        if(fd.optionalBody != null) { this.buildLocalVariableMap(fd.optionalBody, localVars); }
+    }
+
+    private Map buildLocalVariableMap(BlockStatement bs, final Map localVars) throws CompileException {
+        final Map[] resVars = new Map[] { localVars };
+        class UCE extends RuntimeException { final CompileException ce; UCE(CompileException ce) { this.ce = ce; } }
+        BlockStatementVisitor bsv = new BlockStatementVisitor() {
+            // basic statements that use the default handlers
+            public void visitAlternateConstructorInvocation(AlternateConstructorInvocation aci) { UnitCompiler.this.buildLocalVariableMap(aci, localVars); }
+            public void visitBreakStatement(BreakStatement bs)                                  { UnitCompiler.this.buildLocalVariableMap(bs, localVars); }
+            public void visitContinueStatement(ContinueStatement cs)                            { UnitCompiler.this.buildLocalVariableMap(cs, localVars); }
+            public void visitEmptyStatement(EmptyStatement es)                                  { UnitCompiler.this.buildLocalVariableMap(es, localVars); }
+            public void visitExpressionStatement(ExpressionStatement es)                        { UnitCompiler.this.buildLocalVariableMap(es, localVars); }
+            public void visitFieldDeclaration(FieldDeclaration fd)                              { UnitCompiler.this.buildLocalVariableMap(fd, localVars); }
+            public void visitReturnStatement(ReturnStatement rs)                                { UnitCompiler.this.buildLocalVariableMap(rs, localVars); }
+            public void visitSuperConstructorInvocation(SuperConstructorInvocation sci)         { UnitCompiler.this.buildLocalVariableMap(sci, localVars); }
+            public void visitThrowStatement(ThrowStatement ts)                                  { UnitCompiler.this.buildLocalVariableMap(ts, localVars); }
+            public void visitLocalClassDeclarationStatement(LocalClassDeclarationStatement lcds){ UnitCompiler.this.buildLocalVariableMap(lcds, localVars); }
+            
+            // more complicated statements with specialized handlers, but don't add new variables in this scope
+            public void visitBlock(Block b)              					 { try { UnitCompiler.this.buildLocalVariableMap(b , localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitDoStatement(DoStatement ds)                     { try { UnitCompiler.this.buildLocalVariableMap(ds, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitForStatement(ForStatement fs)                   { try { UnitCompiler.this.buildLocalVariableMap(fs, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitIfStatement(IfStatement is)                     { try { UnitCompiler.this.buildLocalVariableMap(is, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitInitializer(Initializer i)                      { try { UnitCompiler.this.buildLocalVariableMap(i , localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitSwitchStatement(SwitchStatement ss)             { try { UnitCompiler.this.buildLocalVariableMap(ss, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitSynchronizedStatement(SynchronizedStatement ss) { try { UnitCompiler.this.buildLocalVariableMap(ss, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitTryStatement(TryStatement ts)                   { try { UnitCompiler.this.buildLocalVariableMap(ts, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitWhileStatement(WhileStatement ws)               { try { UnitCompiler.this.buildLocalVariableMap(ws, localVars); } catch (CompileException e) { throw new UCE(e); } }
+            
+            // more complicated statements with specialized handlers, that can add variables in this scope
+            public void visitLabeledStatement(LabeledStatement ls)                                     { try { resVars[0] = UnitCompiler.this.buildLocalVariableMap(ls  , localVars); } catch (CompileException e) { throw new UCE(e); } }
+            public void visitLocalVariableDeclarationStatement(LocalVariableDeclarationStatement lvds) { try { resVars[0] = UnitCompiler.this.buildLocalVariableMap(lvds, localVars); } catch (CompileException e) { throw new UCE(e); } }
+        };
+        try { bs.accept(bsv); } catch(UCE uce) { throw uce.ce; }
+        return resVars[0];
+    }
+    // default handlers
+    private Map buildLocalVariableMap(Statement s, final Map localVars)              { return s.localVariables = localVars; }
+    private Map buildLocalVariableMap(ConstructorInvocation ci, final Map localVars) { return ci.localVariables = localVars; }
+    
+    // specialized handlers
+    private void buildLocalVariableMap(Block block, Map localVars) throws CompileException {
+        block.localVariables = localVars;
+        for (Iterator it = block.statements.iterator(); it.hasNext();) {
+            BlockStatement bs = (BlockStatement)it.next();
+            localVars = this.buildLocalVariableMap(bs, localVars);
+        }
+    }
+    private void buildLocalVariableMap(DoStatement ds, final Map localVars) throws CompileException {
+        ds.localVariables = localVars;
+        this.buildLocalVariableMap(ds.body, localVars);
+    }
+    private void buildLocalVariableMap(ForStatement fs, final Map localVars) throws CompileException {
+        Map inner = localVars;
+        if(fs.optionalInit != null) {
+            inner = UnitCompiler.this.buildLocalVariableMap(fs.optionalInit, localVars);
+        }
+        fs.localVariables = inner;
+        UnitCompiler.this.buildLocalVariableMap(fs.body, inner);
+    }
+    private void buildLocalVariableMap(IfStatement is, final Map localVars) throws CompileException {
+        is.localVariables = localVars;
+        UnitCompiler.this.buildLocalVariableMap(is.thenStatement, localVars);
+        if(is.optionalElseStatement != null) {
+            UnitCompiler.this.buildLocalVariableMap(is.optionalElseStatement, localVars);
+        }
+    }
+    private void buildLocalVariableMap(Initializer i, final Map localVars) throws CompileException {
+        UnitCompiler.this.buildLocalVariableMap(i.block, localVars);
+    }
+    private void buildLocalVariableMap(SwitchStatement ss, final Map localVars) throws CompileException {
+        ss.localVariables = localVars;
+        Map vars = localVars;
+        for (Iterator cases = ss.sbsgs.iterator(); cases.hasNext();) {
+            SwitchStatement.SwitchBlockStatementGroup sbsg = (SwitchStatement.SwitchBlockStatementGroup) cases.next();
+            for (Iterator stmts = sbsg.blockStatements.iterator(); stmts.hasNext();) {
+                BlockStatement bs = (BlockStatement) stmts.next();
+                vars = UnitCompiler.this.buildLocalVariableMap(bs, vars);
+            }
+        }
+    }
+    private void buildLocalVariableMap(SynchronizedStatement ss, final Map localVars) throws CompileException {
+        ss.localVariables = localVars;
+        UnitCompiler.this.buildLocalVariableMap(ss.body, localVars);
+    }
+    private void buildLocalVariableMap(TryStatement ts, final Map localVars) throws CompileException {
+        ts.localVariables = localVars;
+        UnitCompiler.this.buildLocalVariableMap(ts.body, localVars);
+        for (Iterator it = ts.catchClauses.iterator(); it.hasNext();) {
+            Java.CatchClause cc = (Java.CatchClause) it.next();
+            UnitCompiler.this.buildLocalVariableMap(cc, localVars);
+        }
+        if(ts.optionalFinally != null) {
+            UnitCompiler.this.buildLocalVariableMap(ts.optionalFinally, localVars);
+        }
+    }
+    private void buildLocalVariableMap(WhileStatement ws, final Map localVars) throws CompileException {
+        ws.localVariables = localVars;
+        UnitCompiler.this.buildLocalVariableMap(ws.body, localVars);
+    }
+    
+    private Map buildLocalVariableMap(LabeledStatement ls, final Map localVars) throws CompileException {
+        ls.localVariables = localVars;
+        return UnitCompiler.this.buildLocalVariableMap((BlockStatement)ls.body, localVars);
+    }
+    private Map buildLocalVariableMap(LocalVariableDeclarationStatement lvds, final Map localVars) throws CompileException {
+        Map newVars = new HashMap();
+        newVars.putAll(localVars);
+        for(int i = 0; i < lvds.variableDeclarators.length; ++i) {
+            Java.VariableDeclarator vd = lvds.variableDeclarators[i];
+            Java.LocalVariable lv = UnitCompiler.this.getLocalVariable(lvds, vd);
+            if(newVars.containsKey(vd.name)) this.compileError("Redefinition of local variable \"" + vd.name + "\" ", vd.getLocation());
+            newVars.put(vd.name, lv);
+        }
+        lvds.localVariables = newVars;
+        return newVars;
+    }
+    protected void buildLocalVariableMap(CatchClause cc, Map localVars) throws CompileException {
+        Map vars = new HashMap();
+        vars.putAll(localVars);
+        LocalVariable lv = this.getLocalVariable(cc.caughtException);
+        vars.put(cc.caughtException.name, lv);
+        this.buildLocalVariableMap(cc.body, vars);
+    }
+
+
+
     public Java.LocalVariable getLocalVariable(Java.FunctionDeclarator.FormalParameter fp) throws CompileException {
         if (fp.localVariable == null) {
             fp.localVariable = new Java.LocalVariable(fp.finaL, this.getType(fp.type));
@@ -2394,17 +2588,7 @@
 
         // Check if synthetic method "static Class class$(String className)" is already
         // declared.
-        boolean classDollarMethodDeclared = false;
-        {
-            for (Iterator it = declaringType.declaredMethods.iterator(); it.hasNext();) {
-                Java.MethodDeclarator md = (Java.MethodDeclarator) it.next();
-                if (md.name.equals("class$")) {
-                    classDollarMethodDeclared = true;
-                    break;
-                }
-            }
-        }
-        if (!classDollarMethodDeclared) this.declareClassDollarMethod(cl);
+        if (declaringType.getMethodDeclaration("class$") == null) this.declareClassDollarMethod(cl);
 
         // Determine the statics of the declaring class (this is where static fields
         // declarations are found).
@@ -3591,12 +3775,16 @@
     public boolean generatesCode2(Java.EmptyStatement es) { return false; }
     public boolean generatesCode2(Java.LocalClassDeclarationStatement lcds) { return false; }
     public boolean generatesCode2(Java.Initializer i) throws CompileException { return this.generatesCode(i.block); }
-    public boolean generatesCode2(Java.Block b) throws CompileException {
-        for (int i = 0; i < b.statements.size(); ++i) {
-            if (this.generatesCode(((Java.BlockStatement) b.statements.get(i)))) return true;
+    //takes a List<Java.BlockStatement>
+    public boolean generatesCode2ListStatements(List l) throws CompileException {
+        for (int i = 0; i < l.size(); ++i) {
+            if (this.generatesCode(((Java.BlockStatement) l.get(i)))) return true;
         }
         return false;
     }
+    public boolean generatesCode2(Java.Block b) throws CompileException {
+        return generatesCode2ListStatements(b.statements);
+        }
     public boolean generatesCode2(Java.FieldDeclaration fd) throws CompileException {
         // Code is only generated if at least one of the declared variables has a
         // non-constant-final initializer.
@@ -4154,6 +4342,7 @@
         return this.getType(nia.arrayType);
     }
     private IClass getType2(Java.Literal l) {
+        if (l.value instanceof Byte     ) return IClass.BYTE;
         if (l.value instanceof Integer  ) return IClass.INT;
         if (l.value instanceof Long     ) return IClass.LONG;
         if (l.value instanceof Float    ) return IClass.FLOAT;
@@ -4166,6 +4355,7 @@
     }
     private IClass getType2(Java.ConstantValue cv) {
         IClass res = (
+            cv.constantValue instanceof Byte               ? IClass.BYTE    :
             cv.constantValue instanceof Integer            ? IClass.INT     :
             cv.constantValue instanceof Long               ? IClass.LONG    :
             cv.constantValue instanceof Float              ? IClass.FLOAT   :
@@ -5268,7 +5458,7 @@
         {
             Java.Scope s = scope;
             if (s instanceof Java.BlockStatement) {
-                Java.LocalVariable lv = this.findLocalVariable((Java.BlockStatement) s, identifier);
+                Java.LocalVariable lv = ((Java.BlockStatement) s).findLocalVariable(identifier);
                 if (lv != null) {
                     Java.LocalVariableAccess lva = new Java.LocalVariableAccess(location, lv);
                     if (!(scope instanceof Java.BlockStatement)) throw new RuntimeException("SNO: Local variable access in non-block statement context!?");
@@ -5285,7 +5475,7 @@
                     s = s.getEnclosingScope();
                     if (s instanceof Java.AnonymousClassDeclaration) s = s.getEnclosingScope();
                     while (s instanceof Java.BlockStatement) {
-                        Java.LocalVariable lv = this.findLocalVariable((Java.BlockStatement) s, identifier);
+                        Java.LocalVariable lv = ((Java.BlockStatement)s).findLocalVariable(identifier);
                         if (lv != null) {
                             if (!lv.finaL) this.compileError("Cannot access non-final local variable \"" + identifier + "\" from inner class");
                             final IClass lvType = lv.type;
@@ -5323,7 +5513,8 @@
         for (Java.Scope s = scope; !(s instanceof Java.CompilationUnit); s = s.getEnclosingScope()) {
             if (s instanceof Java.BlockStatement && enclosingBlockStatement == null) enclosingBlockStatement = (Java.BlockStatement) s;
             if (s instanceof Java.TypeDeclaration) {
-                final IClass etd = UnitCompiler.this.resolve((Java.AbstractTypeDeclaration) s);
+                final Java.AbstractTypeDeclaration enclosingTypeDecl = (Java.AbstractTypeDeclaration)s;
+                final IClass etd = UnitCompiler.this.resolve(enclosingTypeDecl);
                 final IClass.IField f = this.findIField(etd, identifier, location);
                 if (f != null) {
                     if (f.isStatic()) {
@@ -5335,7 +5526,7 @@
                         this.warning("IANSFEI", "Implicit access to non-static field \"" + identifier + "\" of enclosing instance (better write \"" + f.getDeclaringIClass() + ".this." + f.getName() + "\")", location);
                     }
 
-                    Java.Type ct = new Java.SimpleType(scopeTypeDeclaration.getLocation(), (IClass) etd);
+                    Java.SimpleType ct = new Java.SimpleType(scopeTypeDeclaration.getLocation(), (IClass) etd);
                     Java.Atom lhs;
                     if (scopeTBD.isStatic()) {
 
@@ -5355,13 +5546,13 @@
                             lhs = new Java.QualifiedThisReference(location, ct);
                         }
                     }
-                    Java.FieldAccess fa = new Java.FieldAccess(
-                        location,
-                        lhs,
-                        f
+                    Java.Rvalue res = new Java.FieldAccess(
+                            location,
+                            lhs,
+                            f
                     );
-                    fa.setEnclosingBlockStatement(enclosingBlockStatement);
-                    return fa;
+                    res.setEnclosingBlockStatement(enclosingBlockStatement);
+                    return res;
                 }
             }
         }
@@ -5476,82 +5667,6 @@
         return new Java.Package(location, identifier);
     }
 
-    /**
-     * Find a local variable declared by the given <code>blockStatement</code> or any enclosing
-     * scope up to the {@link Java.FunctionDeclarator}.
-     */
-    private Java.LocalVariable findLocalVariable(
-        Java.BlockStatement blockStatement,
-        String              name
-    ) throws CompileException {
-        for (Java.Scope s = blockStatement; !(s instanceof Java.CompilationUnit);) {
-            Java.Scope es = s.getEnclosingScope();
-            {
-                if (s instanceof Java.ForStatement) {
-                    Java.BlockStatement optionalForInit = ((Java.ForStatement) s).optionalInit;
-                    if (optionalForInit instanceof Java.LocalVariableDeclarationStatement) {
-                        Java.LocalVariable lv = this.findLocalVariable((Java.LocalVariableDeclarationStatement) optionalForInit, name);
-                        if (lv != null) return lv;
-                    }
-                }
-                if (es instanceof Java.Block) {
-                    Java.Block b = (Java.Block) es;
-                    for (Iterator it = b.statements.iterator();;) {
-                        Java.BlockStatement bs2 = (Java.BlockStatement) it.next();
-                        if (bs2 instanceof Java.LocalVariableDeclarationStatement) {
-                            Java.LocalVariable lv = this.findLocalVariable((Java.LocalVariableDeclarationStatement) bs2, name);
-                            if (lv != null) return lv;
-                        }
-                        if (bs2 == s) break;
-                    }
-                }
-                if (es instanceof Java.SwitchStatement) {
-                    Java.SwitchStatement ss = (Java.SwitchStatement) es;
-                    SBSGS: for (Iterator it2 = ss.sbsgs.iterator();;) {
-                        Java.SwitchStatement.SwitchBlockStatementGroup sbgs = (Java.SwitchStatement.SwitchBlockStatementGroup) it2.next();
-                        for (Iterator it = sbgs.blockStatements.iterator(); it.hasNext();) {
-                            Java.BlockStatement bs2 = (Java.BlockStatement) it.next();
-                            if (bs2 instanceof Java.LocalVariableDeclarationStatement) {
-                                Java.LocalVariable lv = this.findLocalVariable((Java.LocalVariableDeclarationStatement) bs2, name);
-                                if (lv != null) return lv;
-                            }
-                            if (bs2 == s) break SBSGS;
-                        }
-                    }
-                }
-                if (s instanceof Java.FunctionDeclarator) {
-                    Java.FunctionDeclarator fd = (Java.FunctionDeclarator) s;
-                    Java.FunctionDeclarator.FormalParameter[] fps = fd.formalParameters;
-                    for (int i = 0; i < fps.length; ++i) {
-                        if (fps[i].name.equals(name)) return this.getLocalVariable(fps[i]);
-                    }
-                    return null;
-                }
-                if (s instanceof Java.CatchClause) {
-                    Java.CatchClause cc = (Java.CatchClause) s;
-                    if (cc.caughtException.name.equals(name)) return this.getLocalVariable(cc.caughtException);
-                }
-            }
-            s = es;
-        }
-        return null;
-    }
-
-    /**
-     * Check whether the given {@link Java.LocalVariableDeclarationStatement} declares a variable
-     * with the given <code>name</code>.
-     */
-    private Java.LocalVariable findLocalVariable(
-        Java.LocalVariableDeclarationStatement lvds,
-        String                                 name
-    ) throws CompileException {
-        Java.VariableDeclarator[] vds = lvds.variableDeclarators;
-        for (int i = 0; i < vds.length; ++i) {
-            if (vds[i].name.equals(name)) return this.getLocalVariable(lvds, vds[i]);
-        }
-        return null;
-    }
-
     private void determineValue(Java.FieldAccessExpression fae) throws CompileException {
         if (fae.value != null) return;
 
@@ -5574,6 +5689,7 @@
                 };
                 return;
             }
+
             fae.value = new Java.FieldAccess(
                 fae.getLocation(),
                 fae.lhs,
@@ -6672,7 +6788,6 @@
         return importedClass;
     }
     private final Map onDemandImportableTypes = new HashMap();   // String simpleTypeName => IClass
-
     private void declareClassDollarMethod(Java.ClassLiteral cl) {
 
         // Method "class$" is not yet declared; declare it like
@@ -6778,12 +6893,7 @@
         );
 
         declaringType.addDeclaredMethod(cdmd);
-
-        // Invalidate several caches.
-        if (declaringType.resolvedType != null) {
-            declaringType.resolvedType.declaredIMethods = null;
-            declaringType.resolvedType.declaredIMethodCache = null;
-        }
+        declaringType.invalidateMethodCaches();
     }
 
     private IClass pushConstant(Locatable l, Object value) {
@@ -8063,17 +8173,17 @@
     }
 
     private void writeByte(int v) {
-        this.codeContext.write((short) -1, new byte[] { (byte) v });
+        this.codeContext.write((short) -1, (byte) v);
     }
     private void writeShort(int v) {
-        this.codeContext.write((short) -1, new byte[] { (byte) (v >> 8), (byte) v });
+        this.codeContext.write((short) -1, (byte) (v >> 8), (byte) v);
     }
     private void writeInt(int v) {
-        this.codeContext.write((short) -1, new byte[] { (byte) (v >> 24), (byte) (v >> 16), (byte) (v >> 8), (byte) v });
+        this.codeContext.write((short) -1, (byte) (v >> 24), (byte) (v >> 16), (byte) (v >> 8), (byte) v);
     }
 
     private void writeOpcode(Java.Locatable l, int opcode) {
-        this.codeContext.write(l.getLocation().getLineNumber(), new byte[] { (byte) opcode });
+        this.codeContext.write(l.getLocation().getLineNumber(), (byte) opcode);
     }
     private void writeOpcodes(Java.Locatable l, byte[] opcodes) {
         this.codeContext.write(l.getLocation().getLineNumber(), opcodes);
=== src/org/codehaus/janino/Descriptor.java
==================================================================
--- src/org/codehaus/janino/Descriptor.java	(revision 74183)
+++ src/org/codehaus/janino/Descriptor.java	(patch janino-optimize level 1)
@@ -34,6 +34,10 @@
 
 package org.codehaus.janino;
 
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
 /**
  * Helper class that defines useful methods for handling "field descriptors"
  * (JVMS 4.3.2) and "method descriptors" (JVMS 4.3.3).<p>
@@ -128,15 +132,8 @@
      * descriptor.
      */
     public static String fromClassName(String className) {
-        if (className.equals("void"   )) return Descriptor.VOID_;
-        if (className.equals("byte"   )) return Descriptor.BYTE_;
-        if (className.equals("char"   )) return Descriptor.CHAR_;
-        if (className.equals("double" )) return Descriptor.DOUBLE_;
-        if (className.equals("float"  )) return Descriptor.FLOAT_;
-        if (className.equals("int"    )) return Descriptor.INT_;
-        if (className.equals("long"   )) return Descriptor.LONG_;
-        if (className.equals("short"  )) return Descriptor.SHORT_;
-        if (className.equals("boolean")) return Descriptor.BOOLEAN_;
+        String res = (String)Descriptor.classNameToDescriptor.get(className);
+        if(res != null) { return res; }
         if (className.startsWith("[")) return className.replace('.', '/');
         return 'L' + className.replace('.', '/') + ';';
     }
@@ -156,29 +153,18 @@
      * Class#getName()}.
      */
     public static String toClassName(String d) {
-        if (d.length() == 1) {
-            if (d.equals(Descriptor.VOID_   )) return "void";
-            if (d.equals(Descriptor.BYTE_   )) return "byte";
-            if (d.equals(Descriptor.CHAR_   )) return "char";
-            if (d.equals(Descriptor.DOUBLE_ )) return "double";
-            if (d.equals(Descriptor.FLOAT_  )) return "float";
-            if (d.equals(Descriptor.INT_    )) return "int";
-            if (d.equals(Descriptor.LONG_   )) return "long";
-            if (d.equals(Descriptor.SHORT_  )) return "short";
-            if (d.equals(Descriptor.BOOLEAN_)) return "boolean";
-        } else {
-            char firstChar = d.charAt(0);
-            if (firstChar == 'L' && d.endsWith(";")) {
-
-                // Class or interface -- convert "Ljava/lang/String;" to "java.lang.String".
-                return d.substring(1, d.length() - 1).replace('/', '.');
-            } 
-            if (firstChar == '[') {
-
-                // Array type -- convert "[Ljava/lang/String;" to "[Ljava.lang.String;".
-                return d.replace('/', '.');
-            } 
-        }
+        String res = (String)Descriptor.descriptorToClassName.get(d);
+        if(res != null) { return res; }
+        
+        char firstChar = d.charAt(0);
+        if (firstChar == 'L' && d.endsWith(";")) {
+            // Class or interface -- convert "Ljava/lang/String;" to "java.lang.String".
+            return d.substring(1, d.length() - 1).replace('/', '.');
+        } 
+        if (firstChar == '[') {
+            // Array type -- convert "[Ljava/lang/String;" to "[Ljava.lang.String;".
+            return d.replace('/', '.');
+        } 
         throw new RuntimeException("(Invalid field descriptor \"" + d + "\")");
     }
 
@@ -218,15 +204,15 @@
         return packageName1 == null ? packageName2 == null : packageName1.equals(packageName2);
     }
 
-    public final static String VOID_    = "V";
-    public final static String BYTE_    = "B";
-    public final static String CHAR_    = "C";
-    public final static String DOUBLE_  = "D";
-    public final static String FLOAT_   = "F";
-    public final static String INT_     = "I";
-    public final static String LONG_    = "J";
-    public final static String SHORT_   = "S";
-    public final static String BOOLEAN_ = "Z";
+    public final static String VOID_             = "V";
+    public final static String BYTE_             = "B";
+    public final static String CHAR_             = "C";
+    public final static String DOUBLE_           = "D";
+    public final static String FLOAT_            = "F";
+    public final static String INT_              = "I";
+    public final static String LONG_             = "J";
+    public final static String SHORT_            = "S";
+    public final static String BOOLEAN_          = "Z";
     public final static String OBJECT            = "Ljava/lang/Object;";
     public final static String STRING            = "Ljava/lang/String;";
     public final static String STRING_BUFFER     = "Ljava/lang/StringBuffer;";
@@ -237,12 +223,48 @@
     public final static String ERROR             = "Ljava/lang/Error;";
     public final static String CLONEABLE         = "Ljava/lang/Cloneable;";
     public final static String SERIALIZABLE      = "Ljava/io/Serializable;";
-    public final static String BOOLEAN   = "Ljava/lang/Boolean;";
-    public final static String BYTE      = "Ljava/lang/Byte;";
-    public final static String CHARACTER = "Ljava/lang/Character;";
-    public final static String SHORT     = "Ljava/lang/Short;";
-    public final static String INTEGER   = "Ljava/lang/Integer;";
-    public final static String LONG      = "Ljava/lang/Long;";
-    public final static String FLOAT     = "Ljava/lang/Float;";
-    public final static String DOUBLE    = "Ljava/lang/Double;";
+    public final static String BOOLEAN           = "Ljava/lang/Boolean;";
+    public final static String BYTE              = "Ljava/lang/Byte;";
+    public final static String CHARACTER         = "Ljava/lang/Character;";
+    public final static String SHORT             = "Ljava/lang/Short;";
+    public final static String INTEGER           = "Ljava/lang/Integer;";
+    public final static String LONG              = "Ljava/lang/Long;";
+    public final static String FLOAT             = "Ljava/lang/Float;";
+    public final static String DOUBLE            = "Ljava/lang/Double;";
+    private final static Map classNameToDescriptor = new HashMap();
+    private final static Map descriptorToClassName = new HashMap();
+    static {
+        descriptorToClassName.put(Descriptor.VOID_,             "void");
+        descriptorToClassName.put(Descriptor.BYTE_,             "byte");
+        descriptorToClassName.put(Descriptor.CHAR_,             "char");
+        descriptorToClassName.put(Descriptor.DOUBLE_,           "double");
+        descriptorToClassName.put(Descriptor.FLOAT_,            "float");
+        descriptorToClassName.put(Descriptor.INT_,              "int");
+        descriptorToClassName.put(Descriptor.LONG_,             "long");
+        descriptorToClassName.put(Descriptor.SHORT_,            "short");
+        descriptorToClassName.put(Descriptor.BOOLEAN_,          "boolean");
+        descriptorToClassName.put(Descriptor.OBJECT,            "java.lang.Object");
+        descriptorToClassName.put(Descriptor.STRING,            "java.lang.String");
+        descriptorToClassName.put(Descriptor.STRING_BUFFER,     "java.lang.StringBuffer");
+        descriptorToClassName.put(Descriptor.STRING_BUILDER,    "java.lang.StringBuilder");
+        descriptorToClassName.put(Descriptor.CLASS,             "java.lang.Class");
+        descriptorToClassName.put(Descriptor.THROWABLE,         "java.lang.Throwable");
+        descriptorToClassName.put(Descriptor.RUNTIME_EXCEPTION, "java.lang.RuntimeException");
+        descriptorToClassName.put(Descriptor.ERROR,             "java.lang.Error");
+        descriptorToClassName.put(Descriptor.CLONEABLE,         "java.lang.Cloneable");
+        descriptorToClassName.put(Descriptor.SERIALIZABLE,      "java.io.Serializable");
+        descriptorToClassName.put(Descriptor.BOOLEAN,           "java.lang.Boolean");
+        descriptorToClassName.put(Descriptor.BYTE,              "java.lang.Byte");
+        descriptorToClassName.put(Descriptor.CHARACTER,         "java.lang.Character");
+        descriptorToClassName.put(Descriptor.SHORT,             "java.lang.Short");
+        descriptorToClassName.put(Descriptor.INTEGER,           "java.lang.Integer");
+        descriptorToClassName.put(Descriptor.LONG,              "java.lang.Long");
+        descriptorToClassName.put(Descriptor.FLOAT,             "java.lang.Float");
+        descriptorToClassName.put(Descriptor.DOUBLE,            "java.lang.Double");
+        
+        for(Iterator it = descriptorToClassName.entrySet().iterator(); it.hasNext();) {
+            Map.Entry e = (Map.Entry) it.next();
+            classNameToDescriptor.put(e.getValue(), e.getKey());
+        }
+    }
 }
=== src/org/codehaus/janino/CodeContext.java
==================================================================
--- src/org/codehaus/janino/CodeContext.java	(revision 74183)
+++ src/org/codehaus/janino/CodeContext.java	(patch janino-optimize level 1)
@@ -56,8 +56,7 @@
 public class CodeContext {
     private static final boolean DEBUG = false;
 
-    private static final int INITIAL_SIZE   = 100;
-    private static final int SIZE_INCREMENT = 128;
+    private static final int INITIAL_SIZE   = 128;
 
     private /*final*/ ClassFile classFile;
 
@@ -660,6 +659,97 @@
      */
     public void write(short lineNumber, byte[] b) {
         if (b.length == 0) return;
+        
+        int ico = this.currentInserter.offset;
+        this.makeSpace(lineNumber, b.length);
+        System.arraycopy(b, 0, this.code, ico, b.length);
+    }
+    
+    /**
+     * Inserts a byte at the current insertion position. Creates
+     * {@link LineNumberOffset}s as necessary.
+     * <p>
+     * This method is an optimization to avoid allocating small byte[] and ease
+     * GC load.
+     * 
+     * @param lineNumber The line number that corresponds to the byte code, or -1
+     * @param b1
+     */
+    public void write(short lineNumber, byte b1) {
+        int ico = this.currentInserter.offset;
+        this.makeSpace(lineNumber, 1);
+        this.code[ico  ] = b1;
+    }
+    
+    /**
+     * Inserts bytes at the current insertion position. Creates
+     * {@link LineNumberOffset}s as necessary.
+     * <p>
+     * This method is an optimization to avoid allocating small byte[] and ease
+     * GC load.
+     * 
+     * @param lineNumber The line number that corresponds to the byte code, or -1
+     * @param b1
+     * @param b2
+     */
+    public void write(short lineNumber, byte b1, byte b2) {
+        int ico = this.currentInserter.offset;
+        this.makeSpace(lineNumber, 2);
+        this.code[ico++] = b1;
+        this.code[ico  ] = b2;
+    }
+    
+    /**
+     * Inserts bytes at the current insertion position. Creates
+     * {@link LineNumberOffset}s as necessary.
+     * <p>
+     * This method is an optimization to avoid allocating small byte[] and ease
+     * GC load.
+     * 
+     * @param lineNumber The line number that corresponds to the byte code, or -1
+     * @param b1
+     * @param b2
+     * @param b3
+     */
+    public void write(short lineNumber, byte b1, byte b2, byte b3) {
+        int ico = this.currentInserter.offset;
+        this.makeSpace(lineNumber, 3);
+        this.code[ico++] = b1;
+        this.code[ico++] = b2;
+        this.code[ico  ] = b3;
+    }
+    
+    /**
+     * Inserts bytes at the current insertion position. Creates
+     * {@link LineNumberOffset}s as necessary.
+     * <p>
+     * This method is an optimization to avoid allocating small byte[] and ease
+     * GC load.
+     * 
+     * @param lineNumber The line number that corresponds to the byte code, or -1
+     * @param b1
+     * @param b2
+     * @param b3
+     * @param b4
+     */
+    public void write(short lineNumber, byte b1, byte b2, byte b3, byte b4) {
+        int ico = this.currentInserter.offset;
+        this.makeSpace(lineNumber, 4);
+        this.code[ico++] = b1;
+        this.code[ico++] = b2;
+        this.code[ico++] = b3;
+        this.code[ico  ] = b4;
+    }
+    
+    /**
+     * Add space for size bytes at current offset. Creates
+     * {@link LineNumberOffset}s as necessary.
+     *  
+     * @param lineNumber The line number that corresponds to the byte code, or -1
+     * @param size       The size in bytes to inject
+     */
+    public void makeSpace(short lineNumber, int size) {
+        if (size == 0) return;
 
         INSERT_LINE_NUMBER_OFFSET:
         if (lineNumber != -1) {
@@ -678,24 +768,29 @@
         }
 
         int ico = this.currentInserter.offset;
-        if (this.end.offset + b.length <= this.code.length) {
-            System.arraycopy(this.code, ico, this.code, ico + b.length, this.end.offset - ico);
+        if (this.end.offset + size <= this.code.length) {
+            // Optimization to avoid a trivial method call in the common case
+            if(ico != this.end.offset) {
+                System.arraycopy(this.code, ico, this.code, ico + size, this.end.offset - ico);
+            }
         } else {
             byte[] oldCode = this.code;
-            this.code = new byte[this.code.length + CodeContext.SIZE_INCREMENT];
-            if (this.code.length >= 0xffff) throw new RuntimeException("Code attribute in class \"" + this.classFile.getThisClassName() + "\" grows beyond 64 KB");
+            //double size to avoid horrible performance, but don't grow over our limit
+            int newSize = Math.max(Math.min(oldCode.length * 2, 0xffff), oldCode.length + size);
+            this.code = new byte[newSize];
+            if (this.code.length > 0xffff) throw new RuntimeException("Code attribute in class \"" + this.classFile.getThisClassName() + "\" grows beyond 64 KB");
             System.arraycopy(oldCode, 0, this.code, 0, ico);
-            System.arraycopy(oldCode, ico, this.code, ico + b.length, this.end.offset - ico);
-        }
-        System.arraycopy(b, 0, this.code, ico, b.length);
-        for (Offset o = this.currentInserter; o != null; o = o.next) o.offset += b.length;
+            System.arraycopy(oldCode, ico, this.code, ico + size, this.end.offset - ico);
+        }  
+        Arrays.fill(this.code, ico, ico+size, (byte)0);
+        for (Offset o = this.currentInserter; o != null; o = o.next) o.offset += size;
     }
 
     /**
      * @param lineNumber The line number that corresponds to the byte code, or -1
      */
     public void writeShort(short lineNumber, int v) {
-        this.write(lineNumber, new byte[] { (byte) (v >> 8), (byte) v });
+        this.write(lineNumber, (byte) (v >> 8), (byte) v);
     }
 
     /**
@@ -703,7 +798,7 @@
      */
     public void writeBranch(short lineNumber, int opcode, final Offset dst) {
         this.relocatables.add(new Branch(opcode, dst));
-        this.write(lineNumber, new byte[] { (byte) opcode, -1, -1 });
+        this.write(lineNumber, (byte)opcode, (byte)-1, (byte)-1);
     }
 
     private class Branch extends Relocatable {
@@ -730,9 +825,9 @@
                 CodeContext.this.pushInserter(this.source); {
                     // promotion to a wide instruction only requires 2 extra bytes 
                     // everything else requires a new GOTO_W instruction after a negated if
-                    CodeContext.this.write(
+                    CodeContext.this.makeSpace(
                         (short) -1, 
-                        new byte[this.opcode == Opcode.GOTO ? 2 : this.opcode == Opcode.JSR ? 2 : 5]
+                        this.opcode == Opcode.GOTO ? 2 : this.opcode == Opcode.JSR ? 2 : 5
                     );
                 } CodeContext.this.popInserter();
                 this.source.offset = pos;
@@ -816,7 +911,7 @@
 
     public void writeOffset(short lineNumber, Offset src, final Offset dst) {
         this.relocatables.add(new OffsetBranch(this.newOffset(), src, dst));
-        this.write(lineNumber, new byte[] { -1, -1, -1, -1 });
+        this.write(lineNumber, (byte)-1, (byte)-1, (byte)-1, (byte)-1);
     }
 
     private class OffsetBranch extends Relocatable {
=== src/org/codehaus/janino/Java.java
==================================================================
--- src/org/codehaus/janino/Java.java	(revision 74183)
+++ src/org/codehaus/janino/Java.java	(patch janino-optimize level 1)
@@ -34,10 +34,17 @@
 
 package org.codehaus.janino;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
 
-import org.codehaus.janino.util.*;
-import org.codehaus.janino.util.iterator.*;
+import org.codehaus.janino.util.Traverser;
+import org.codehaus.janino.util.iterator.ReverseListIterator;
 
 
 /**
@@ -77,6 +84,7 @@
         private final Location location;
 
         protected Located(Location location) {
+            //assert location != null;
             this.location = location;
         }
 
@@ -360,6 +368,13 @@
             method.setDeclaringType(this);
         }
 
+        public void invalidateMethodCaches() {
+            if (this.resolvedType != null) {
+                this.resolvedType.declaredIMethods = null;
+                this.resolvedType.declaredIMethodCache = null;
+            }
+        }
+
         // Implement TypeDeclaration.
         public void addMemberTypeDeclaration(MemberTypeDeclaration mcoid) {
             this.declaredClassesAndInterfaces.add(mcoid);
@@ -375,6 +390,13 @@
             }
             return null;
         }
+        public MethodDeclarator getMethodDeclaration(String name) {
+            for (Iterator it = this.declaredMethods.iterator(); it.hasNext();) {
+                MethodDeclarator md = (MethodDeclarator) it.next();
+                if (md.name.equals(name)) return md;
+            }
+            return null;
+        }
         public String createLocalTypeName(String localTypeName) {
             return (
                 this.getClassName()
@@ -880,6 +902,10 @@
 
         public final void accept(Visitor.TypeBodyDeclarationVisitor visitor) { visitor.visitInitializer(this); }
         public final void accept(Visitor.BlockStatementVisitor visitor) { visitor.visitInitializer(this); }
+        
+        public Java.LocalVariable findLocalVariable(String name) {
+            return this.block.findLocalVariable(name);
+        }
     }
 
     /**
@@ -955,6 +981,9 @@
         
             public Java.LocalVariable localVariable = null;
         }
+        
+        // Compile time members
+        public Map localVariables = null; // String name => Java.LocalVariable
     }
 
     public static final class ConstructorDeclarator extends FunctionDeclarator {
@@ -1164,6 +1193,7 @@
         Scope getEnclosingScope();
 
         void accept(Visitor.BlockStatementVisitor visitor);
+        Java.LocalVariable findLocalVariable(String name);
     }
 
     public static abstract class Statement extends Located implements BlockStatement {
@@ -1179,6 +1209,13 @@
             this.enclosingScope = enclosingScope;
         }
         public Scope getEnclosingScope() { return this.enclosingScope; }
+        
+        // Compile time members
+        public Map localVariables = null; // String name => Java.LocalVariable
+        public Java.LocalVariable findLocalVariable(String name) {
+            if(this.localVariables == null) { return null; }
+            return (LocalVariable) this.localVariables.get(name);
+        }
     }
 
     public final static class LabeledStatement extends BreakableStatement {
@@ -1239,7 +1276,6 @@
         }
 
         // Compile time members.
-
         public final void accept(Visitor.BlockStatementVisitor visitor) { visitor.visitBlock(this); }
 
         public String toString() {
@@ -1511,7 +1547,7 @@
             if (x != 0) {
                 CodeContext ca = this.getCodeContext();
                 ca.pushInserter(this); {
-                    ca.write((short) -1, new byte[4 - x]);
+                    ca.makeSpace((short)-1, 4-x);
                 } ca.popInserter();
             }
         }
@@ -2521,6 +2557,13 @@
             this.enclosingScope = enclosingScope;
         }
         public Scope getEnclosingScope() { return this.enclosingScope; }
+        
+        // Compile time members
+        public Map localVariables = null; // String name => Java.LocalVariable
+        public Java.LocalVariable findLocalVariable(String name) {
+            if(this.localVariables == null) { return null; }
+            return (LocalVariable) this.localVariables.get(name);
+        }
     }
 
     public final static class AlternateConstructorInvocation extends ConstructorInvocation {
@@ -2737,6 +2780,23 @@
         public final Rvalue[] dimExprs;
         public final int      dims;
 
+        /**
+         * Create a new array with dimension dimExprs.length + dims
+         * <p>
+         * e.g. byte[12][][] is created with
+         *     new NewArray(
+         *         null,
+         *         Java.BasicType(NULL, Java.BasicType.BYTE),
+         *         new Rvalue[] {
+         *             new Java.Literal(null, Integer.valueOf(12)
+         *         },
+         *         2
+         *     )
+         * @param location  the location of this element
+         * @param type      the base type of the array
+         * @param dimExprs  sizes for dimensions being allocated with specific sizes
+         * @param dims      the number of dimensions that are not yet allocated
+         */
         public NewArray(
             Location location,
             Type     type,
=== src/org/codehaus/janino/SimpleCompiler.java
==================================================================
--- src/org/codehaus/janino/SimpleCompiler.java	(revision 74183)
+++ src/org/codehaus/janino/SimpleCompiler.java	(patch janino-optimize level 1)
@@ -201,7 +201,7 @@
     public static final ClassLoader BOOT_CLASS_LOADER = new ClassLoader(null) {};
 
     /**
-     * Allowe references to the classes loaded through this parent class loader
+     * Allow references to the classes loaded through this parent class loader
      * (@see {@link #setParentClassLoader(ClassLoader)}), plus the extra
      * <code>auxiliaryClasses</code>.
      * <p>
@@ -233,7 +233,22 @@
             DebuggingInformation.DEFAULT_DEBUGGING_INFORMATION
         );
     }
+    
+    /**
+     * Cook this compilation unit directly. 
+     *  See {@link Cookable.cook}
+     */
+    public void cook(Java.CompilationUnit compilationUnit)
+    throws CompileException, Parser.ParseException, Scanner.ScanException, IOException {
+        this.setUpClassLoaders();
 
+        // Compile the classes and load them.
+        this.compileToClassLoader(
+            compilationUnit,
+            DebuggingInformation.DEFAULT_DEBUGGING_INFORMATION
+        );
+    }
+
     /**
      * Initializes {@link #classLoader} and {@link #iClassLoader} from the configured
      * {@link #parentClassLoader} and {@link #optionalAuxiliaryClasses}. These are needed by
=== src/org/codehaus/janino/UnparseVisitor.java
==================================================================
--- src/org/codehaus/janino/UnparseVisitor.java	(revision 74183)
+++ src/org/codehaus/janino/UnparseVisitor.java	(patch janino-optimize level 1)
@@ -34,8 +34,16 @@
 
 package org.codehaus.janino;
 
-import java.io.*;
-import java.util.*;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
 
 import org.codehaus.janino.util.AutoIndentWriter;
 
@@ -44,8 +52,8 @@
  * {@link #main(String[])} for a usage example.
  */
 public class UnparseVisitor implements Visitor.ComprehensiveVisitor {
-    private final AutoIndentWriter aiw;
-    private final PrintWriter      pw;
+    protected final AutoIndentWriter aiw;
+    protected final PrintWriter      pw;
 
     /**
      * Testing of parsing/unparsing.
@@ -210,13 +218,13 @@
         this.pw.print("for (");
         if (fs.optionalInit != null) {
             this.unparseBlockStatement(fs.optionalInit);
-        } else {
+        } else { 
             this.pw.print(';');
         }
         if (fs.optionalCondition != null) {
             this.pw.print(' ');
             this.unparse(fs.optionalCondition);
-        }
+        } 
         this.pw.print(';');
         if (fs.optionalUpdate != null) {
             this.pw.print(' ');
@@ -261,7 +269,7 @@
         if (rs.optionalReturnValue != null) {
             this.pw.print(' ');
             this.unparse(rs.optionalReturnValue);
-        }
+        } 
         this.pw.print(';');
     }
     public void visitSwitchStatement(Java.SwitchStatement ss) {
@@ -506,7 +514,7 @@
 
     /**
      * Iff the <code>operand</code> is unnatural for the <code>unaryOperator</code>, enclose the
-     * <code>operand</code> in parentheses. Example: "a+b" is an unnatural operand for unary "!x".
+     * <code>operand</code> in parentheses. Example: "a+b" is an unnatural operand for unary "!x". 
      *
      * @param unaryOperator ++x --x +x -x ~x !x x++ x--
      */
@@ -517,7 +525,7 @@
 
     /**
      * Iff the <code>lhs</code> is unnatural for the <code>binaryOperator</code>, enclose the
-     * <code>lhs</code> in parentheses. Example: "a+b" is an unnatural lhs for operator "*".
+     * <code>lhs</code> in parentheses. Example: "a+b" is an unnatural lhs for operator "*". 
      *
      * @param binaryOperator = +=... ?: || && | ^ & == != < > <= >= instanceof << >> >>> + - * / % cast
      */
@@ -530,7 +538,7 @@
 
     /**
      * Iff the <code>rhs</code> is unnatural for the <code>binaryOperator</code>, enclose the
-     * <code>rhs</code> in parentheses. Example: "a+b" is an unnatural rhs for operator "*".
+     * <code>rhs</code> in parentheses. Example: "a+b" is an unnatural rhs for operator "*". 
      */
     private void unparseRhs(Java.Rvalue rhs, String binaryOperator) {
         int cmp = UnparseVisitor.comparePrecedence(binaryOperator, rhs);
@@ -538,7 +546,7 @@
     }
 
     private void unparse(Java.Atom operand, boolean natural) {
-        if (!natural) this.pw.print("((( ");
+        if (!natural) this.pw.print("((( ");
         this.unparse(operand);
         if (!natural) this.pw.print(" )))");
     }
@@ -573,25 +581,25 @@
      */
     private static int comparePrecedence(String operator, Java.Atom operand) {
         if (operand instanceof Java.BinaryOperation) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence(((Java.BinaryOperation) operand).op);
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence(((Java.BinaryOperation) operand).op); 
         } else
         if (operand instanceof Java.UnaryOperation) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence(((Java.UnaryOperation) operand).operator + "x");
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence(((Java.UnaryOperation) operand).operator + "x"); 
         } else
         if (operand instanceof Java.ConditionalExpression) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("?:");
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("?:"); 
         } else
         if (operand instanceof Java.Instanceof) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("instanceof");
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("instanceof"); 
         } else
         if (operand instanceof Java.Cast) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("cast");
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("cast"); 
         } else
         if (operand instanceof Java.MethodInvocation || operand instanceof Java.FieldAccess) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence(".");
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("."); 
         } else
         if (operand instanceof Java.NewArray) {
-            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("new");
+            return UnparseVisitor.getOperatorPrecedence(operator) - UnparseVisitor.getOperatorPrecedence("new"); 
         } else
         if (operand instanceof Java.Crement) {
             Java.Crement c = (Java.Crement) operand;
@@ -650,7 +658,7 @@
         if (ncd.optionalExtendedType != null) {
             this.pw.print(" extends ");
             this.unparseType(ncd.optionalExtendedType);
-        }
+        } 
         if (ncd.implementedTypes.length > 0) this.pw.print(" implements " + Java.join(ncd.implementedTypes, ", "));
         this.pw.println(" {");
         this.unparseClassDeclarationBody(ncd);
@@ -772,4 +780,5 @@
         }
         this.pw.print(')');
     }
+
 }
=== src/org/codehaus/janino/util/Traverser.java
==================================================================
--- src/org/codehaus/janino/util/Traverser.java	(revision 74183)
+++ src/org/codehaus/janino/util/Traverser.java	(patch janino-optimize level 1)
@@ -488,7 +488,7 @@
         fa.lhs.accept(this.cv);
         this.traverseLvalue(fa);
     }
-
+    
     public void traverseFieldAccessExpression(Java.FieldAccessExpression fae) {
         fae.lhs.accept(this.cv);
         this.traverseLvalue(fae);

==== BEGIN SVK PATCH BLOCK ====
Version: svk v2.0.2 (linux)
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==== END SVK PATCH BLOCK ====