diff --git a/community/codegen/src/main/java/org/neo4j/codegen/CatchClause.java b/community/codegen/src/main/java/org/neo4j/codegen/CatchClause.java
new file mode 100644
index 000000000000..d37fa2d070e0
--- /dev/null
+++ b/community/codegen/src/main/java/org/neo4j/codegen/CatchClause.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2002-2016 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.codegen;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+public class CatchClause
+{
+    private final Parameter exception;
+    private final List<Consumer<MethodEmitter>> actions;
+
+    public CatchClause( Parameter exception, List<Consumer<MethodEmitter>> actions )
+    {
+        this.exception = exception;
+        this.actions = actions;
+    }
+
+    public Parameter exception()
+    {
+        return exception;
+    }
+
+    public List<Consumer<MethodEmitter>> actions()
+    {
+        return actions;
+    }
+
+}
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/CodeBlock.java b/community/codegen/src/main/java/org/neo4j/codegen/CodeBlock.java
index 17996fa55f77..f6f8226f0849 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/CodeBlock.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/CodeBlock.java
@@ -19,20 +19,21 @@
  */
 package org.neo4j.codegen;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.function.Consumer;
 
+import static org.neo4j.codegen.LocalVariables.copy;
 import static org.neo4j.codegen.Resource.withResource;
 import static org.neo4j.codegen.TypeReference.typeReference;
 
 public class CodeBlock implements AutoCloseable
 {
+
     final ClassGenerator clazz;
     private MethodEmitter emitter;
     private final CodeBlock parent;
     private boolean done;
-    private Map<String, LocalVariable> localVariables = new HashMap<>(  );
-    private int varCount = 0;
+
+    protected LocalVariables localVariables = new LocalVariables();
 
     CodeBlock( CodeBlock parent )
     {
@@ -40,7 +41,8 @@ public class CodeBlock implements AutoCloseable
         this.emitter = parent.emitter;
         parent.emitter = InvalidState.IN_SUB_BLOCK;
         this.parent = parent;
-        this.localVariables = parent.localVariables;
+        //copy over local variables from parent
+        this.localVariables = copy(parent.localVariables);
     }
 
     CodeBlock( ClassGenerator clazz, MethodEmitter emitter, Parameter...parameters )
@@ -48,10 +50,10 @@ public class CodeBlock implements AutoCloseable
         this.clazz = clazz;
         this.emitter = emitter;
         this.parent = null;
-        localVariables.put("this", localVariable( clazz.handle(), "this" ) );
+        localVariables.createNew( clazz.handle(), "this" );
         for ( Parameter parameter : parameters )
         {
-            localVariables.put( parameter.name(), localVariable( parameter.type(), parameter.name() ) );
+            localVariables.createNew( parameter.type(), parameter.name() );
         }
     }
 
@@ -75,7 +77,7 @@ public void close()
         this.emitter = InvalidState.BLOCK_CLOSED;
     }
 
-    private void endBlock()
+    protected void endBlock()
     {
         if ( !done )
         {
@@ -84,9 +86,14 @@ private void endBlock()
         }
     }
 
+    protected void emit( Consumer<MethodEmitter> emitFunction )
+    {
+        emitFunction.accept( emitter );
+    }
+
     public void expression( Expression expression )
     {
-        emitter.expression( expression );
+        emit( ( e ) -> e.expression( expression ) );
     }
 
     LocalVariable local( String name )
@@ -96,15 +103,14 @@ LocalVariable local( String name )
 
     public LocalVariable declare( TypeReference type, String name )
     {
-        LocalVariable local = localVariable( type, name );
-        localVariables.put(name, local);
-        emitter.declare( local );
+        LocalVariable local = localVariables.createNew( type, name );
+        emit( e -> e.declare( local ) );
         return local;
     }
 
     public void assign( LocalVariable local, Expression value )
     {
-        emitter.assignVariableInScope( local, value );
+        emit( e -> e.assignVariableInScope( local, value ) );
     }
 
     public void assign( Class<?> type, String name, Expression value )
@@ -114,14 +120,13 @@ public void assign( Class<?> type, String name, Expression value )
 
     public void assign( TypeReference type, String name, Expression value )
     {
-        LocalVariable variable = localVariable( type, name );
-        localVariables.put(name, variable );
-        emitter.assign( variable, value );
+        LocalVariable variable = localVariables.createNew( type, name );
+        emit( e -> e.assign( variable, value ) );
     }
 
     public void put( Expression target, FieldReference field, Expression value )
     {
-        emitter.put( target, field, value );
+        emit( e -> e.put( target, field, value ) );
     }
 
     public Expression self()
@@ -136,65 +141,50 @@ public Expression load( String name )
 
     public CodeBlock forEach( Parameter local, Expression iterable )
     {
-        emitter.beginForEach( local, iterable );
+        emit( e -> e.beginForEach( local, iterable ) );
         return new CodeBlock( this );
     }
 
     public CodeBlock whileLoop( Expression test )
     {
-        emitter.beginWhile( test );
+        emit( e -> e.beginWhile( test ) );
         return new CodeBlock( this );
     }
 
     public CodeBlock ifStatement( Expression test )
     {
-        emitter.beginIf( test );
+        emit( e -> e.beginIf( test ) );
         return new CodeBlock( this );
     }
 
-    CodeBlock emitCatch( Parameter exception )
-    {
-        endBlock();
-        emitter.beginCatch( exception );
-        return new CodeBlock( this );
-    }
-
-    CodeBlock emitFinally()
-    {
-        endBlock();
-        emitter.beginFinally();
-        return new CodeBlock( this );
-    }
-
-    public CodeBlock tryBlock( Class<?> resourceType, String resourceName, Expression resource )
+    public TryBlock tryBlock( Class<?> resourceType, String resourceName, Expression resource )
     {
         return tryBlock( withResource( resourceType, resourceName, resource ) );
     }
 
-    public CodeBlock tryBlock( TypeReference resourceType, String resourceName, Expression resource )
+    public TryBlock tryBlock( TypeReference resourceType, String resourceName, Expression resource )
     {
         return tryBlock( withResource( resourceType, resourceName, resource ) );
     }
 
     public TryBlock tryBlock( Resource... resources )
     {
-        emitter.beginTry( resources );
-        return new TryBlock( this );
+        return new TryBlock( this, resources );
     }
 
     public void returns()
     {
-        emitter.returns();
+        emit( MethodEmitter::returns );
     }
 
     public void returns( Expression value )
     {
-        emitter.returns( value );
+        emit( e -> e.returns( value ) );
     }
 
     public void throwException( Expression exception )
     {
-        emitter.throwException( exception );
+        emit( e -> e.throwException( exception ) );
     }
 
     public TypeReference owner()
@@ -202,8 +192,4 @@ public TypeReference owner()
         return clazz.handle();
     }
 
-    private LocalVariable localVariable( TypeReference type, String name )
-    {
-        return new LocalVariable( type, name, varCount++ );
-    }
 }
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/Expression.java b/community/codegen/src/main/java/org/neo4j/codegen/Expression.java
index bdea9e3bd0c1..49f377a1abc6 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/Expression.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/Expression.java
@@ -70,7 +70,7 @@ public void accept( ExpressionVisitor visitor )
         };
     }
 
-    static Expression load( final LocalVariable variable)
+    public static Expression load( final LocalVariable variable)
     {
         return new Expression()
         {
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/InvalidState.java b/community/codegen/src/main/java/org/neo4j/codegen/InvalidState.java
index 69fe7cadf9aa..fb1e4149f258 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/InvalidState.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/InvalidState.java
@@ -19,6 +19,9 @@
  */
 package org.neo4j.codegen;
 
+import java.util.List;
+import java.util.function.Consumer;
+
 class InvalidState implements MethodEmitter
 {
     public static final ClassEmitter CLASS_DONE = new ClassEmitter()
@@ -98,12 +101,6 @@ public void beginIf( Expression test )
         throw new IllegalStateException( reason );
     }
 
-    @Override
-    public void beginFinally()
-    {
-        throw new IllegalStateException( reason );
-    }
-
     @Override
     public void endBlock()
     {
@@ -111,7 +108,8 @@ public void endBlock()
     }
 
     @Override
-    public void beginTry( Resource... resources )
+    public void tryCatchBlock( List<Consumer<MethodEmitter>> body, List<CatchClause> catchClauses,
+            List<Consumer<MethodEmitter>> finalClauses, LocalVariables localVariables, Resource... resources )
     {
         throw new IllegalStateException( reason );
     }
@@ -122,12 +120,6 @@ public void throwException( Expression exception )
         throw new IllegalStateException( reason );
     }
 
-    @Override
-    public void beginCatch( Parameter exception )
-    {
-        throw new IllegalStateException( reason );
-    }
-
     @Override
     public void declare( LocalVariable local )
     {
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/LocalVariables.java b/community/codegen/src/main/java/org/neo4j/codegen/LocalVariables.java
new file mode 100644
index 000000000000..5ccffec4d454
--- /dev/null
+++ b/community/codegen/src/main/java/org/neo4j/codegen/LocalVariables.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2002-2016 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.codegen;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Repository of local variables.
+ */
+public class LocalVariables
+{
+    private final AtomicInteger counter = new AtomicInteger( 0 );
+    private final Map<String,LocalVariable> localVariables = new HashMap<>();
+
+    public LocalVariable createNew( TypeReference type, String name )
+    {
+        LocalVariable localVariable = new LocalVariable( type, name, counter.getAndIncrement() );
+        localVariables.put( name, localVariable );
+        return localVariable;
+    }
+
+    public LocalVariable get( String name )
+    {
+        return localVariables.get( name );
+    }
+
+    public static LocalVariables copy( LocalVariables original )
+    {
+        LocalVariables variables = new LocalVariables();
+        variables.counter.set( original.counter.get() );
+        original.localVariables.forEach( variables.localVariables::put );
+        return variables;
+    }
+
+    public int nextIndex()
+    {
+        return counter.getAndIncrement();
+    }
+}
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/MethodEmitter.java b/community/codegen/src/main/java/org/neo4j/codegen/MethodEmitter.java
index 9e4e6f8d7443..543bae50c8b5 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/MethodEmitter.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/MethodEmitter.java
@@ -19,6 +19,9 @@
  */
 package org.neo4j.codegen;
 
+import java.util.List;
+import java.util.function.Consumer;
+
 public interface MethodEmitter
 {
     void done();
@@ -37,16 +40,15 @@ public interface MethodEmitter
 
     void beginIf( Expression test );
 
-    void beginFinally();
-
     void endBlock();
 
-    void beginTry( Resource... resources );
+    void tryCatchBlock( List<Consumer<MethodEmitter>> body,
+            List<CatchClause> catchClauses,
+            List<Consumer<MethodEmitter>> finalClauses,
+            LocalVariables localVariables, Resource... resources );
 
     void throwException( Expression exception );
 
-    void beginCatch( Parameter exception );
-
     void declare( LocalVariable local );
 
     void assignVariableInScope( LocalVariable local, Expression value );
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/MethodReference.java b/community/codegen/src/main/java/org/neo4j/codegen/MethodReference.java
index 86eb65e1b426..592f2315c9d9 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/MethodReference.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/MethodReference.java
@@ -46,6 +46,12 @@ private static MethodReference methodReference( Class<?> owner, TypeReference re
         return methodReference( typeReference( owner ), returns, name, modifiers, parameters );
     }
 
+    public static MethodReference methodReference( TypeReference owner, TypeReference returns, String name,
+            TypeReference... parameters )
+    {
+        return new MethodReference( owner, name, returns, Modifier.PUBLIC, parameters );
+    }
+
     public static MethodReference methodReference( TypeReference owner, TypeReference returns, String name,
             int modifiers, TypeReference... parameters )
     {
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/TryBlock.java b/community/codegen/src/main/java/org/neo4j/codegen/TryBlock.java
index cf1843fb8be2..18ed9b35365a 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/TryBlock.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/TryBlock.java
@@ -19,20 +19,165 @@
  */
 package org.neo4j.codegen;
 
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+/**
+ * TryBlock are not really block but tries to look like it from an API standpoint.
+ * Keeps a state-machine to figure out which state we're in (try, catch, finally).
+ * It is not until we call the last "try block" we actually call close on the actual
+ * code block and generates code for the entire try-catch block at once.
+ */
 public class TryBlock extends CodeBlock
 {
-    TryBlock( CodeBlock parent )
+    private final Resource[] resources;
+    private final State tryState = newState( null );
+    private final List<CatchState> catchStates = new LinkedList<>();
+    private State finallyState = null;
+
+    private State currentState = tryState;
+
+    TryBlock( CodeBlock parent, Resource... resources )
     {
         super( parent );
+        this.resources = resources;
     }
 
     public CodeBlock catchBlock(Parameter exception)
     {
-        return emitCatch(exception);
+        CatchState catchState = new CatchState( exception, currentState );
+        this.currentState = catchState;
+        catchStates.add( catchState );
+        return this;
     }
 
     public CodeBlock finallyBlock()
     {
-        return emitFinally();
+        if ( finallyState != null )
+        {
+            throw new IllegalStateException( "Cannot have more than one finally block" );
+        }
+        finallyState = newState( currentState );
+        currentState = finallyState;
+        return this;
+    }
+
+    @Override
+    protected void emit( Consumer<MethodEmitter> emitFunction )
+    {
+        currentState.addAction( emitFunction );
+    }
+
+    @Override
+    public void close()
+    {
+        State nextState = currentState.nextState();
+        if ( nextState == null )
+        {
+            super.emit( ( e ) -> e.tryCatchBlock( tryActions(), catchClauses(), finallyActions(), localVariables, resources ) );
+            super.close();
+        }
+        currentState = nextState;
+
+    }
+
+    @Override
+    protected void endBlock()
+    {
+        //do nothing
+    }
+
+    private List<Consumer<MethodEmitter>> tryActions()
+    {
+        return tryState.actions();
+    }
+
+    private List<CatchClause> catchClauses()
+    {
+        return catchStates.stream().map( c -> new CatchClause( c.exception, c.actions) )
+                .collect( Collectors.toList() );
+    }
+
+    private List<Consumer<MethodEmitter>> finallyActions()
+    {
+        return finallyState == null ? Collections.emptyList() : finallyState.actions();
+    }
+
+    /**
+     * A Try block can be in different states depending on if we're in try, catch or finally.
+     * When nextState returns <tt>null</tt> it means we have no more blocks left and should close
+     * the underlying code block.
+     */
+    private interface State
+    {
+
+        void addAction( Consumer<MethodEmitter> action );
+
+        List<Consumer<MethodEmitter>> actions();
+
+        State nextState();
+    }
+
+    /**
+     * Catch states are special states that stores what kind of exception we are catching.
+     */
+    private static class CatchState implements State
+    {
+
+        private final List<Consumer<MethodEmitter>> actions = new LinkedList<>();
+        private final Parameter exception;
+        private final State parent;
+
+        CatchState( Parameter exception, State parent )
+        {
+            this.exception = exception;
+            this.parent = parent;
+        }
+
+        @Override
+        public void addAction( Consumer<MethodEmitter> action )
+        {
+            actions.add( action );
+        }
+
+        @Override
+        public List<Consumer<MethodEmitter>> actions()
+        {
+            return actions;
+        }
+
+        @Override
+        public State nextState()
+        {
+            return parent;
+        }
+    }
+    private State newState( State parent )
+    {
+        return new State()
+        {
+            private final List<Consumer<MethodEmitter>> actions = new LinkedList<>();
+
+            @Override
+            public void addAction( Consumer<MethodEmitter> action )
+            {
+                actions.add( action );
+            }
+
+            @Override
+            public List<Consumer<MethodEmitter>> actions()
+            {
+                return actions;
+            }
+
+            @Override
+            public State nextState()
+            {
+                return parent;
+            }
+        };
     }
 }
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/bytecode/ByteCodeExpressionVisitor.java b/community/codegen/src/main/java/org/neo4j/codegen/bytecode/ByteCodeExpressionVisitor.java
index 0d44158326c0..a429061f2979 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/bytecode/ByteCodeExpressionVisitor.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/bytecode/ByteCodeExpressionVisitor.java
@@ -196,6 +196,7 @@ public void or( Expression lhs, Expression rhs )
         methodVisitor.visitInsn( ICONST_1 );
         Label l2 = new Label();
         methodVisitor.visitJumpInsn( GOTO, l2 );
+        methodVisitor.visitLabel( l1 );
         methodVisitor.visitInsn( ICONST_0 );
         methodVisitor.visitLabel( l2 );
 
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/bytecode/If.java b/community/codegen/src/main/java/org/neo4j/codegen/bytecode/If.java
index 9efa81a7911d..6d1dbf593923 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/bytecode/If.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/bytecode/If.java
@@ -38,6 +38,5 @@ public If( MethodVisitor methodVisitor, Label l0)
     public void endBlock()
     {
         methodVisitor.visitLabel( l0 );
-        methodVisitor.visitFrame( F_SAME, 0, null, 0, null );
     }
 }
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/bytecode/MethodByteCodeEmitter.java b/community/codegen/src/main/java/org/neo4j/codegen/bytecode/MethodByteCodeEmitter.java
index 041cfc6824b7..5776de79ca65 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/bytecode/MethodByteCodeEmitter.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/bytecode/MethodByteCodeEmitter.java
@@ -24,13 +24,18 @@
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
+import java.util.ArrayList;
 import java.util.Deque;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Consumer;
 
 import org.neo4j.codegen.BaseExpressionVisitor;
+import org.neo4j.codegen.CatchClause;
 import org.neo4j.codegen.Expression;
 import org.neo4j.codegen.FieldReference;
 import org.neo4j.codegen.LocalVariable;
+import org.neo4j.codegen.LocalVariables;
 import org.neo4j.codegen.MethodDeclaration;
 import org.neo4j.codegen.MethodEmitter;
 import org.neo4j.codegen.MethodReference;
@@ -44,6 +49,7 @@
 import static org.neo4j.codegen.ByteCodeUtils.outerName;
 import static org.neo4j.codegen.ByteCodeUtils.signature;
 import static org.neo4j.codegen.ByteCodeUtils.typeName;
+import static org.neo4j.codegen.MethodReference.methodReference;
 
 class MethodByteCodeEmitter implements MethodEmitter, Opcodes
 {
@@ -121,6 +127,7 @@ public void returns( Expression value )
         case "byte":
         case "short":
         case "char":
+        case "boolean":
             methodVisitor.visitInsn( IRETURN );
             break;
         case "long":
@@ -162,7 +169,6 @@ public void assign( LocalVariable variable, Expression value )
         default:
             methodVisitor.visitVarInsn( ASTORE, variable.index() );
         }
-
     }
 
     @Override
@@ -190,11 +196,6 @@ public void beginIf( Expression test )
         stateStack.push(new If(methodVisitor, l0));
     }
 
-    @Override
-    public void beginFinally()
-    {
-        callSuperIfNecessary();
-    }
 
     @Override
     public void endBlock()
@@ -209,19 +210,153 @@ public void endBlock()
     }
 
     @Override
-    public void beginTry( Resource... resources )
+    public void tryCatchBlock( List<Consumer<MethodEmitter>> body, List<CatchClause> catchClauses,
+            List<Consumer<MethodEmitter>> finalClauses, LocalVariables localVariables, Resource... resources )
     {
         callSuperIfNecessary();
+        //Note we are not giving the same gurantee as built in try-with-resources
+        //we are essentially rewriting to:
+        //Resource resource = ...
+        //try...
+        //finally { ... resource.close}
+        List<Consumer<MethodEmitter>> updatedFinalClauses = resources.length == 0 ?
+                                                            finalClauses : new ArrayList<>( finalClauses );
+        for ( Resource resource : resources )
+        {
+            LocalVariable variable = localVariables.createNew( resource.type(), resource.name() );
+            assign( variable, resource.producer() );
+
+            MethodReference close = methodReference( resource.type(), TypeReference.VOID, "close" );
+            updatedFinalClauses.add( ( e ) -> e.expression(
+                    Expression.invoke( Expression.load( variable ), close ) ) );
+        }
+
+        if ( !catchClauses.isEmpty() )
+        {
+           tryCatchFinally( body, catchClauses, updatedFinalClauses, localVariables );
+        }
+        else
+        {
+            tryFinally( body, updatedFinalClauses, localVariables );
+        }
     }
 
-    @Override
-    public void throwException( Expression exception )
+    private void tryFinally(List<Consumer<MethodEmitter>> body,
+            List<Consumer<MethodEmitter>> finalClauses, LocalVariables localVariables)
     {
-        callSuperIfNecessary();
+        Label startLabel = new Label();
+        Label endLabel = new Label();
+        Label continueLabel = new Label();
+        //if we have a simple try {} finally {} we only need to run finally after body
+        //and make sure we catch any errors and then run finally and rethrow
+        Label handlerLabel = new Label();
+        methodVisitor.visitTryCatchBlock( startLabel, endLabel, handlerLabel, null );
+        methodVisitor.visitLabel( startLabel );
+        body.forEach( e -> e.accept( this ) );
+        methodVisitor.visitLabel( endLabel );
+        //run finally on success
+        finalClauses.forEach( e -> e.accept( this ) );
+
+        int indexToStoreException = localVariables.nextIndex();
+        //catch error and run finally
+        methodVisitor.visitJumpInsn( GOTO, continueLabel );
+        methodVisitor.visitLabel( handlerLabel );
+        //store error
+        methodVisitor.visitVarInsn( ASTORE, indexToStoreException );
+        finalClauses.forEach( e -> e.accept( this ) );
+        //catch and rethrow
+        methodVisitor.visitVarInsn( ALOAD, indexToStoreException );
+        methodVisitor.visitInsn( ATHROW );
+        methodVisitor.visitLabel( continueLabel );
+    }
+
+    private void tryCatchFinally(List<Consumer<MethodEmitter>> body, List<CatchClause> catchClauses,
+            List<Consumer<MethodEmitter>> finalClauses, LocalVariables localVariables)
+    {
+        Label startLabel = new Label();
+        Label endLabel = new Label();
+        Label continueLabel = new Label();
+        //if we have catch clauses we need to catch error, run body create labels for each catch clauses
+        //we also need to make sure that the final clauses run both after body and after each catch block
+        //and also make sure if any of the catch clauses fail we still run finally
+
+        //generate try-catch block for each catch clause
+        List<Label> handlerLabels = new ArrayList<>( catchClauses.size() );
+        catchClauses.forEach(
+                c -> {
+                    Label handlerLabel = new Label();
+                    methodVisitor.visitTryCatchBlock( startLabel, endLabel, handlerLabel,
+                            byteCodeName( c.exception().type() ) );
+                    handlerLabels.add( handlerLabel );
+                } );
+
+        //generate try-catch block for handling finally
+        List<Label> endLabelsForFinal = new ArrayList<>( catchClauses.size() );
+        Label handlerLabelFinal = new Label();
+        Label endFinal = new Label();
+        if ( !finalClauses.isEmpty() )
+        {
+            methodVisitor.visitTryCatchBlock( startLabel, endLabel, handlerLabelFinal, null );
+            for ( Label handlerLabel : handlerLabels )
+            {
+                Label endCatchLabel = new Label();
+                methodVisitor.visitTryCatchBlock( handlerLabel, endCatchLabel, handlerLabelFinal, null );
+                endLabelsForFinal.add( endCatchLabel );
+            }
+            methodVisitor.visitTryCatchBlock( handlerLabelFinal, endFinal, handlerLabelFinal, null );
+        }
+
+        //run body
+        methodVisitor.visitLabel( startLabel );
+        body.forEach( e -> e.accept( this ) );
+        methodVisitor.visitLabel( endLabel );
+
+        //if body succeeded we need to run final
+        finalClauses.forEach( e -> e.accept( this ) );
+
+        //handle catch
+        int indexToStoreException = localVariables.nextIndex();
+        for ( int i = 0; i < catchClauses.size(); i++ )
+        {
+            CatchClause catchClause = catchClauses.get( i );
+            Label handlerLabel = handlerLabels.get( i );
+            methodVisitor.visitJumpInsn( GOTO, continueLabel );
+            methodVisitor.visitLabel( handlerLabel );
+            //store exception for later use
+            methodVisitor.visitVarInsn( ASTORE, indexToStoreException );
+            catchClause.actions().forEach( e -> e.accept( this ) );
+
+            //run final clauses on failure
+            if ( !finalClauses.isEmpty() )
+            {
+                methodVisitor.visitLabel( endLabelsForFinal.get( i ) );
+                finalClauses.forEach( e -> e.accept( this ) );
+            }
+        }
+
+        if ( !finalClauses.isEmpty() )
+        {
+            indexToStoreException = localVariables.nextIndex();
+            //need to catch exceptions on finally
+            methodVisitor.visitJumpInsn( GOTO, continueLabel );
+            methodVisitor.visitLabel( handlerLabelFinal );
+            methodVisitor.visitVarInsn( ASTORE, indexToStoreException );
+            methodVisitor.visitLabel( endFinal );
+
+            //run finally again
+            finalClauses.forEach( e -> e.accept( this ) );
+
+            //rethrow
+            methodVisitor.visitVarInsn( ALOAD, indexToStoreException );
+            methodVisitor.visitInsn( ATHROW );
+        }
+
+        //continue
+        methodVisitor.visitLabel( continueLabel );
     }
 
     @Override
-    public void beginCatch( Parameter exception )
+    public void throwException( Expression exception )
     {
         callSuperIfNecessary();
     }
diff --git a/community/codegen/src/main/java/org/neo4j/codegen/source/MethodSourceWriter.java b/community/codegen/src/main/java/org/neo4j/codegen/source/MethodSourceWriter.java
index 8ee0bccb65d4..e3b02015bdb9 100644
--- a/community/codegen/src/main/java/org/neo4j/codegen/source/MethodSourceWriter.java
+++ b/community/codegen/src/main/java/org/neo4j/codegen/source/MethodSourceWriter.java
@@ -23,11 +23,15 @@
 
 import java.util.Deque;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Consumer;
 
+import org.neo4j.codegen.CatchClause;
 import org.neo4j.codegen.Expression;
 import org.neo4j.codegen.ExpressionVisitor;
 import org.neo4j.codegen.FieldReference;
 import org.neo4j.codegen.LocalVariable;
+import org.neo4j.codegen.LocalVariables;
 import org.neo4j.codegen.MethodEmitter;
 import org.neo4j.codegen.MethodReference;
 import org.neo4j.codegen.Parameter;
@@ -163,8 +167,7 @@ public void beginIf( Expression test )
         level.push( LEVEL );
     }
 
-    @Override
-    public void beginCatch( Parameter exception )
+    private void beginCatch( Parameter exception )
     {
         indent().append( "catch ( " ).append( exception.type().name() ).append( " " ).append( exception.name() )
                 .append( " )\n" );
@@ -172,16 +175,14 @@ public void beginCatch( Parameter exception )
         level.push( LEVEL );
     }
 
-    @Override
-    public void beginFinally()
+    private void beginFinally()
     {
         indent().append( "finally\n" );
         indent().append( "{\n" );
         level.push( LEVEL );
     }
 
-    @Override
-    public void beginTry( final Resource... resources )
+    private void beginTry( final Resource... resources )
     {
         if ( resources.length > 0 && classSourceWriter.configuration.isSet( SourceCode.SIMPLIFY_TRY_WITH_RESOURCE ) )
         {
@@ -223,6 +224,51 @@ public void beginTry( final Resource... resources )
         }
     }
 
+    @Override
+    public void tryCatchBlock( List<Consumer<MethodEmitter>> body,
+            List<CatchClause> catchClauses,
+            List<Consumer<MethodEmitter>> finalClauses, LocalVariables localVariables, Resource... resources )
+    {
+        //try
+        beginTry(resources);
+        body.forEach( e -> e.accept( this ) );
+        endBlock();
+        //catch
+        catchClauses.forEach( ( c ) -> {
+            beginCatch( c.exception() );
+            c.actions().forEach( e -> e.accept( this ) );
+            endBlock();
+        } );
+        if ( !finalClauses.isEmpty() )
+        {
+            beginFinally();
+            finalClauses.forEach( e -> e.accept( this ) );
+            endBlock();
+        }
+    }
+//
+//        indent().append( "try\n" );
+//        indent().append( "{\n" );
+//        indent();
+//        body.forEach( e -> e.accept( this ) );
+//        indent().append( '}' );
+//        for ( CatchClause catchClause : catchClauses )
+//        {
+//            indent().append( "catch ( " ).append( catchClause.exception().type().name() ).append( " " )
+//                    .append( catchClause.exception().name() )
+//                    .append( " )\n" );
+//            indent().append( "{\n" );
+//           catchClause.actions().forEach( e -> e.accept( this ) );
+//        }
+//        indent().append( '}' );
+//        if (!finalClauses.isEmpty())
+//        {
+//            indent().append( "finally\n" );
+//            indent().append( "{\n" );
+//            finalClauses.forEach( e -> e.accept( this ) );
+//            indent().append( '}' );
+//        }
+
     @Override
     public void throwException( Expression exception )
     {
diff --git a/community/codegen/src/test/java/org/neo4j/codegen/CodeGenerationTest.java b/community/codegen/src/test/java/org/neo4j/codegen/CodeGenerationTest.java
index 31017ad3e895..7e0e51f9b1b8 100644
--- a/community/codegen/src/test/java/org/neo4j/codegen/CodeGenerationTest.java
+++ b/community/codegen/src/test/java/org/neo4j/codegen/CodeGenerationTest.java
@@ -37,6 +37,7 @@
 import org.neo4j.codegen.source.Configuration;
 import org.neo4j.codegen.source.SourceCode;
 
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
@@ -49,6 +50,7 @@
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.verifyZeroInteractions;
@@ -56,6 +58,7 @@
 import static org.neo4j.codegen.Expression.invoke;
 import static org.neo4j.codegen.Expression.newArray;
 import static org.neo4j.codegen.Expression.newInstance;
+import static org.neo4j.codegen.Expression.or;
 import static org.neo4j.codegen.ExpressionTemplate.cast;
 import static org.neo4j.codegen.ExpressionTemplate.load;
 import static org.neo4j.codegen.ExpressionTemplate.self;
@@ -555,6 +558,35 @@ public void shouldGenerateOr() throws Throwable
         verifyZeroInteractions( runner4 );
     }
 
+    @Test
+    public void shouldGenerateMethodUsingOr() throws Throwable
+    {
+        // given
+        ClassHandle handle;
+        try ( ClassGenerator simple = generateClass( "SimpleClass" ) )
+        {
+            try ( CodeBlock conditional = simple.generateMethod( boolean.class, "conditional",
+                    param( boolean.class, "test1" ), param( boolean.class, "test2" )) )
+            {
+                conditional.returns( or( conditional.load( "test1" ), conditional.load( "test2" ) ) );
+            }
+
+            handle = simple.handle();
+        }
+
+
+        // when
+        MethodHandle conditional =
+                instanceMethod( handle.newInstance(), "conditional", boolean.class, boolean.class);
+
+        // then
+        assertThat(conditional.invoke( true, true), equalTo(true));
+        assertThat(conditional.invoke( true, false), equalTo(true));
+        assertThat(conditional.invoke( false, true), equalTo(true));
+        assertThat(conditional.invoke( false, false), equalTo(false));
+    }
+
+
     public static class ResourceFactory
     {
         int open, close, inside;
@@ -603,6 +635,102 @@ public void shouldGenerateTryWithResourceBlock() throws Throwable
         assertEquals( 1, factory.close );
     }
 
+    @Test
+    public void shouldGenerateTryCatch() throws Throwable
+    {
+        // given
+        ClassHandle handle;
+        try ( ClassGenerator simple = generateClass( "SimpleClass" ) )
+        {
+            try ( CodeBlock run = simple.generateMethod( void.class, "run",
+                    param( Runnable.class, "body" ),
+                    param( Runnable.class, "catcher" ) ) )
+            {
+                try ( TryBlock tryBlock = run.tryBlock() )
+                {
+                    tryBlock.expression( invoke( run.load( "body" ), RUN ) );
+                    try ( CodeBlock catchBlock = tryBlock.catchBlock(param(RuntimeException.class, "E")) )
+                    {
+                        catchBlock.expression( invoke( run.load( "catcher" ), RUN ) );
+                    }
+                }
+            }
+            handle = simple.handle();
+        }
+
+        // when
+        Runnable successBody = mock( Runnable.class ),
+                failBody = mock( Runnable.class ),
+                successCatch = mock( Runnable.class ), failCatch = mock( Runnable.class );
+        RuntimeException theFailure = new RuntimeException();
+        doThrow( theFailure ).when( failBody ).run();
+        MethodHandle run = instanceMethod( handle.newInstance(), "run", Runnable.class, Runnable.class );
+
+
+        //success
+        run.invoke( successBody, successCatch );
+        verify( successBody ).run();
+        verify( successCatch, never() ).run();
+
+        //failure
+        run.invoke( failBody, failCatch );
+        InOrder orderFailure = inOrder( failBody, failCatch );
+        orderFailure.verify( failBody ).run();
+        orderFailure.verify( failCatch ).run();
+    }
+
+    @Test
+    public void shouldGenerateTryAndMultipleCatch() throws Throwable
+    {
+        // given
+        ClassHandle handle;
+        try ( ClassGenerator simple = generateClass( "SimpleClass" ) )
+        {
+            try ( CodeBlock run = simple.generateMethod( void.class, "run",
+                    param( Runnable.class, "body" ),
+                    param( Runnable.class, "catcher1" ),
+                    param( Runnable.class, "catcher2" ) ) )
+            {
+                try ( TryBlock tryBlock = run.tryBlock() )
+                {
+                    tryBlock.expression( invoke( run.load( "body" ), RUN ) );
+                    try ( CodeBlock catchBlock = tryBlock.catchBlock( param( MyFirstException.class, "E" ) ) )
+                    {
+                        catchBlock.expression( invoke( run.load( "catcher1" ), RUN ) );
+                    }
+                    try ( CodeBlock catchBlock = tryBlock.catchBlock( param( MySecondException.class, "E" ) ) )
+                    {
+                        catchBlock.expression( invoke( run.load( "catcher2" ), RUN ) );
+                    }
+                }
+            }
+            handle = simple.handle();
+        }
+
+        // when
+
+        Runnable body1 = mock( Runnable.class ), body2 = mock( Runnable.class ),
+                catcher11 = mock( Runnable.class ), catcher12 = mock( Runnable.class ),
+                catcher21 = mock( Runnable.class ), catcher22 = mock( Runnable.class );
+        doThrow( MyFirstException.class ).when( body1 ).run();
+        doThrow( MySecondException.class ).when( body2 ).run();
+
+        MethodHandle run =
+                instanceMethod( handle.newInstance(), "run", Runnable.class, Runnable.class, Runnable.class );
+
+
+        run.invoke( body1, catcher11, catcher12 );
+        verify( body1 ).run();
+        verify( catcher11 ).run();
+        verify( catcher12, never() ).run();
+
+
+        run.invoke( body2, catcher21, catcher22 );
+        verify( body2 ).run();
+        verify( catcher22 ).run();
+        verify( catcher21, never() ).run();
+    }
+
     @Test
     public void shouldGenerateTryFinally() throws Throwable
     {
@@ -646,6 +774,121 @@ public void shouldGenerateTryFinally() throws Throwable
         order.verify( finalize ).run();
     }
 
+    @Test
+    public void shouldGenerateTryCatchFinally() throws Throwable
+    {
+        // given
+        ClassHandle handle;
+        try ( ClassGenerator simple = generateClass( "SimpleClass" ) )
+        {
+            try ( CodeBlock run = simple.generateMethod( void.class, "run",
+                    param( Runnable.class, "body" ),
+                    param( Runnable.class, "catcher" ),
+                    param( Runnable.class, "finalize" ) ) )
+            {
+                try ( TryBlock tryBlock = run.tryBlock() )
+                {
+                    tryBlock.expression( invoke( run.load( "body" ), RUN ) );
+                    try ( CodeBlock catchBlock = tryBlock.catchBlock( param( RuntimeException.class, "E" ) ) )
+                    {
+                        catchBlock.expression( invoke( run.load( "catcher" ), RUN ) );
+                    }
+                    try ( CodeBlock finallyBlock = tryBlock.finallyBlock() )
+                    {
+                        finallyBlock.expression( invoke( run.load( "finalize" ), RUN ) );
+                    }
+                }
+            }
+            handle = simple.handle();
+        }
+
+        // when
+        Runnable successBody = mock( Runnable.class ), failBody = mock( Runnable.class ),
+                successCatch = mock( Runnable.class ), failCatch = mock( Runnable.class ),
+                successFinally = mock( Runnable.class ), failFinally = mock( Runnable.class );
+        RuntimeException theFailure = new RuntimeException();
+        doThrow( theFailure ).when( failBody ).run();
+        MethodHandle run =
+                instanceMethod( handle.newInstance(), "run", Runnable.class, Runnable.class, Runnable.class );
+
+        //success
+        run.invoke( successBody, successCatch, successFinally );
+        verify( successBody ).run();
+        verify( successCatch, never() ).run();
+        verify( successFinally ).run();
+
+        //failure
+        run.invoke( failBody, failCatch, failFinally );
+        InOrder order = inOrder( failBody, failCatch, failFinally );
+        order.verify( failBody ).run();
+        order.verify( failCatch ).run();
+        order.verify( failFinally ).run();
+    }
+
+    @Test
+    public void shouldGenerateTryMultipleCatchAndFinally() throws Throwable
+    {
+        // given
+        ClassHandle handle;
+        try ( ClassGenerator simple = generateClass( "SimpleClass" ) )
+        {
+            try ( CodeBlock run = simple.generateMethod( void.class, "run",
+                    param( Runnable.class, "body" ),
+                    param( Runnable.class, "catcher1" ),
+                    param( Runnable.class, "catcher2" ),
+                    param( Runnable.class, "finalize" )
+            ) )
+            {
+                try ( TryBlock tryBlock = run.tryBlock() )
+                {
+                    tryBlock.expression( invoke( run.load( "body" ), RUN ) );
+                    try ( CodeBlock catchBlock = tryBlock.catchBlock( param( MyFirstException.class, "E" ) ) )
+                    {
+                        catchBlock.expression( invoke( run.load( "catcher1" ), RUN ) );
+                    }
+                    try ( CodeBlock catchBlock = tryBlock.catchBlock( param( MySecondException.class, "E" ) ) )
+                    {
+                        catchBlock.expression( invoke( run.load( "catcher2" ), RUN ) );
+                    }
+                    try ( CodeBlock finallyBlock = tryBlock.finallyBlock() )
+                    {
+                        finallyBlock.expression( invoke( run.load( "finalize" ), RUN ) );
+                    }
+                }
+            }
+            handle = simple.handle();
+        }
+
+        // when
+
+        Runnable body1 = mock( Runnable.class ), body2 = mock( Runnable.class ),
+                catcher11 = mock( Runnable.class ), catcher12 = mock( Runnable.class ), finalize1 =
+                mock( Runnable.class ),
+                catcher21 = mock( Runnable.class ), catcher22 = mock( Runnable.class ), finalize2 =
+                mock( Runnable.class );
+        doThrow( MyFirstException.class ).when( body1 ).run();
+        doThrow( MySecondException.class ).when( body2 ).run();
+
+        MethodHandle run =
+                instanceMethod( handle.newInstance(), "run", Runnable.class, Runnable.class, Runnable.class,
+                        Runnable.class );
+
+
+        run.invoke( body1, catcher11, catcher12, finalize1 );
+        verify( body1 ).run();
+        verify( catcher11 ).run();
+        verify( catcher12, never() ).run();
+        verify( finalize1 ).run();
+
+
+        run.invoke( body2, catcher21, catcher22, finalize2 );
+        verify( body2 ).run();
+        verify( catcher22 ).run();
+        verify( catcher21, never() ).run();
+        verify( finalize2 ).run();
+    }
+
+
     @Test
     public void shouldThrowException() throws Throwable
     {
@@ -816,4 +1059,13 @@ private static MethodReference createMethod(Class<?> owner, Class<?> returnType,
             throw new AssertionError( "Cannot create method", e );
         }
     }
+
+    public static class MyFirstException extends RuntimeException
+    {
+    }
+
+    public static class MySecondException extends RuntimeException
+    {
+    }
+
 }
diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/GeneratedQueryStructure.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/GeneratedQueryStructure.scala
index 88aebde05d0c..956f545b46f4 100644
--- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/GeneratedQueryStructure.scala
+++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/GeneratedQueryStructure.scala
@@ -814,8 +814,8 @@ private object Templates {
   val newCountingMap = Expression.invoke(method[Primitive,PrimitiveLongIntMap]("longIntMap"))
 
   def asList(values: Seq[Expression]): Expression = Expression.invoke(
-    methodReference(typeRef[util.Arrays], typeRef[util.List[String]], "asList", typeRef[Array[String]]),
-    values: _*)
+    methodReference(typeRef[util.Arrays], typeRef[util.List[String]], "asList", typeRef[Array[Object]]),
+    Expression.newArray(typeRef[String], values: _*))
 
   def handleExceptions[V](generate: CodeBlock, ro: FieldReference)(block: CodeBlock => V) = using(generate.tryBlock()) { body =>
     // the body of the try
diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/GeneratedQueryStructure.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/GeneratedQueryStructure.scala
index dbb1db620b26..59bcedd7d254 100644
--- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/GeneratedQueryStructure.scala
+++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/GeneratedQueryStructure.scala
@@ -19,6 +19,7 @@
  */
 package org.neo4j.cypher.internal.spi.v3_0
 
+import java.lang.reflect.Modifier
 import java.util
 
 import org.neo4j.codegen
@@ -142,7 +143,7 @@ object GeneratedQueryStructure extends CodeStructure[GeneratedQuery] {
   }
 
   def method[O <: AnyRef, R](name: String, params: TypeReference*)(implicit owner: Manifest[O], returns: Manifest[R]): MethodReference =
-    MethodReference.methodReference(typeReference(owner), typeReference(returns), name, params: _*)
+    MethodReference.methodReference(typeReference(owner), typeReference(returns), name, Modifier.PUBLIC, params: _*)
 
   def staticField[O <: AnyRef, R](name: String)(implicit owner: Manifest[O], fieldType: Manifest[R]): FieldReference =
     FieldReference.staticField(typeReference(owner), typeReference(fieldType), name)
@@ -846,8 +847,8 @@ private object Templates {
   val newCountingMap = Expression.invoke(method[Primitive,PrimitiveLongIntMap]("longIntMap"))
 
   def asList(values: Seq[Expression]): Expression = Expression.invoke(
-    methodReference(typeRef[util.Arrays], typeRef[util.List[String]], "asList", typeRef[Array[String]]),
-    values: _*)
+    methodReference(typeRef[util.Arrays], typeRef[util.List[String]], "asList", typeRef[Array[Object]]),
+      Expression.newArray(typeRef[String], values: _*))
 
   def handleExceptions[V](generate: CodeBlock, ro: FieldReference)(block: CodeBlock => V) = using(generate.tryBlock()) { body =>
     // the body of the try