diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesLambdaWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesLambdaWriter.java
index 5005e33..4f7f5d9 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesLambdaWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesLambdaWriter.java
@@ -19,6 +19,7 @@
 
 package org.codehaus.groovy.classgen.asm.sc;
 
+import org.apache.groovy.util.ObjectHolder;
 import org.codehaus.groovy.GroovyBugError;
 import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
 import org.codehaus.groovy.ast.ClassHelper;
@@ -135,8 +136,8 @@
                 addDeserializeLambdaMethod();
             }
 
-            newGroovyLambdaWrapperAndLoad(lambdaWrapperClassNode, expression);
-            loadEnclosingClassInstance();
+            newGroovyLambdaWrapperAndLoad(lambdaWrapperClassNode, syntheticLambdaMethodNode, expression);
+            loadEnclosingClassInstance(syntheticLambdaMethodNode);
         }
 
         MethodVisitor mv = controller.getMethodVisitor();
@@ -160,12 +161,12 @@
         return new Parameter[]{new Parameter(ClassHelper.SERIALIZEDLAMBDA_TYPE, SERIALIZED_LAMBDA_PARAM_NAME)};
     }
 
-    private void loadEnclosingClassInstance() {
+    private void loadEnclosingClassInstance(MethodNode syntheticLambdaMethodNode) {
         MethodVisitor mv = controller.getMethodVisitor();
         OperandStack operandStack = controller.getOperandStack();
         CompileStack compileStack = controller.getCompileStack();
 
-        if (controller.isStaticMethod() || compileStack.isInSpecialConstructorCall()) {
+        if (controller.isStaticMethod() || compileStack.isInSpecialConstructorCall() || !isAccessingInstanceMembers(syntheticLambdaMethodNode)) {
             operandStack.pushConstant(ConstantExpression.NULL);
         } else {
             mv.visitVarInsn(ALOAD, 0);
@@ -173,13 +174,46 @@
         }
     }
 
-    private void newGroovyLambdaWrapperAndLoad(ClassNode lambdaWrapperClassNode, LambdaExpression expression) {
+    private boolean isAccessingInstanceMembers(MethodNode syntheticLambdaMethodNode) {
+        ObjectHolder<Boolean> objectHolder = new ObjectHolder<>(false);
+        ClassCodeVisitorSupport classCodeVisitorSupport = new ClassCodeVisitorSupport() {
+            @Override
+            public void visitVariableExpression(VariableExpression expression) {
+                if (expression.isThisExpression()) {
+                    objectHolder.setObject(true);
+                }
+            }
+
+            @Override
+            public void visitMethodCallExpression(MethodCallExpression call) {
+                if (!call.getMethodTarget().isStatic()) {
+                    Expression objectExpression = call.getObjectExpression();
+                    if (objectExpression instanceof VariableExpression && ENCLOSING_THIS.equals(((VariableExpression) objectExpression).getName())) {
+                        objectHolder.setObject(true);
+                    }
+                }
+
+                super.visitMethodCallExpression(call);
+            }
+
+            @Override
+            protected SourceUnit getSourceUnit() {
+                return null;
+            }
+        };
+
+        classCodeVisitorSupport.visitMethod(syntheticLambdaMethodNode);
+
+        return objectHolder.getObject();
+    }
+
+    private void newGroovyLambdaWrapperAndLoad(ClassNode lambdaWrapperClassNode, MethodNode syntheticLambdaMethodNode, LambdaExpression expression) {
         MethodVisitor mv = controller.getMethodVisitor();
         String lambdaWrapperClassInternalName = BytecodeHelper.getClassInternalName(lambdaWrapperClassNode);
         mv.visitTypeInsn(NEW, lambdaWrapperClassInternalName);
         mv.visitInsn(DUP);
 
-        loadEnclosingClassInstance();
+        loadEnclosingClassInstance(syntheticLambdaMethodNode);
         controller.getOperandStack().dup();
 
         loadSharedVariables(expression);
diff --git a/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java b/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java
index 7d2db8d..e8557a7 100644
--- a/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/StaticImportVisitor.java
@@ -100,25 +100,26 @@
 
     public Expression transform(Expression exp) {
         if (exp == null) return null;
-        if (exp.getClass() == VariableExpression.class) {
+        Class<? extends Expression> clazz = exp.getClass();
+        if (clazz == VariableExpression.class) {
             return transformVariableExpression((VariableExpression) exp);
         }
-        if (exp.getClass() == BinaryExpression.class) {
+        if (clazz == BinaryExpression.class) {
             return transformBinaryExpression((BinaryExpression) exp);
         }
-        if (exp.getClass() == PropertyExpression.class) {
+        if (clazz == PropertyExpression.class) {
             return transformPropertyExpression((PropertyExpression) exp);
         }
-        if (exp.getClass() == MethodCallExpression.class) {
+        if (clazz == MethodCallExpression.class) {
             return transformMethodCallExpression((MethodCallExpression) exp);
         }
-        if (exp.getClass() == ClosureExpression.class) {
+        if (exp instanceof ClosureExpression) {
             return transformClosureExpression((ClosureExpression) exp);
         }
-        if (exp.getClass() == ConstructorCallExpression.class) {
+        if (clazz == ConstructorCallExpression.class) {
             return transformConstructorCallExpression((ConstructorCallExpression) exp);
         }
-        if (exp.getClass() == ArgumentListExpression.class) {
+        if (clazz == ArgumentListExpression.class) {
             Expression result = exp.transformExpression(this);
             if (inPropertyExpression) {
                 foundArgs = result;
diff --git a/src/test/groovy/transform/stc/LambdaTest.groovy b/src/test/groovy/transform/stc/LambdaTest.groovy
index 4612741..672aab3 100644
--- a/src/test/groovy/transform/stc/LambdaTest.groovy
+++ b/src/test/groovy/transform/stc/LambdaTest.groovy
@@ -955,6 +955,26 @@
         '''
     }
 
+    void testInitializeBlocks() {
+        assertScript '''
+            import java.util.stream.Collectors
+            
+            @groovy.transform.CompileStatic
+            class Test1 {
+                static sl
+                def il
+                static { sl = [1, 2, 3].stream().map(e -> e + 1).toList() }
+                 
+                {
+                    il = [1, 2, 3].stream().map(e -> e + 2).toList()
+                }
+            }
+            
+            assert [2, 3, 4] == Test1.sl
+            assert [3, 4, 5] == new Test1().il
+        '''
+    }
+
     void testSerialize() {
         assertScript '''
         import java.util.function.Function
@@ -962,8 +982,7 @@
         interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             def p() {
                     def out = new ByteArrayOutputStream()
                     out.withObjectOutputStream {
@@ -980,12 +999,11 @@
     }
 
     void testSerializeFailed() {
-        shouldFail(NotSerializableException, '''
+        def errMsg = shouldFail(NotSerializableException, '''
         import java.util.function.Function
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             def p() {
                     def out = new ByteArrayOutputStream()
                     out.withObjectOutputStream {
@@ -999,6 +1017,8 @@
 
         new Test1().p()
         ''')
+
+        assert errMsg.contains('$Lambda$')
     }
 
     void testDeserialize() {
@@ -1007,8 +1027,7 @@
         import java.util.function.Function
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             byte[] p() {
                     def out = new ByteArrayOutputStream()
                     out.withObjectOutputStream {
@@ -1031,14 +1050,83 @@
         '''
     }
 
+    void testDeserializeLambdaInInitializeBlock() {
+        assertScript '''
+            package tests.lambda
+            import java.util.function.Function
+            
+            @groovy.transform.CompileStatic
+            class Test1 implements Serializable {
+                private static final long serialVersionUID = -1L;
+                String a = 'a'
+                SerializableFunction<Integer, String> f
+                 
+                {
+                    f = ((Integer e) -> a + e)
+                }
+                
+                byte[] p() {
+                    def out = new ByteArrayOutputStream()
+                    out.withObjectOutputStream {
+                        it.writeObject(f)
+                    }
+                    
+                    return out.toByteArray()
+                }
+                
+                static void main(String[] args) {
+                    new ByteArrayInputStream(new Test1().p()).withObjectInputStream(Test1.class.classLoader) {
+                        SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
+                        assert 'a1' == f.apply(1)
+                    }
+                }
+                
+                interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
+            }
+        '''
+    }
+
+    void testDeserializeLambdaInInitializeBlockShouldFail() {
+        def errMsg = shouldFail(NotSerializableException, '''
+            package tests.lambda
+            import java.util.function.Function
+            
+            @groovy.transform.CompileStatic
+            class Test1 {
+                String a = 'a'
+                SerializableFunction<Integer, String> f
+                 
+                {
+                    f = ((Integer e) -> a + e)
+                }
+                
+                byte[] p() {
+                    def out = new ByteArrayOutputStream()
+                    out.withObjectOutputStream {
+                        it.writeObject(f)
+                    }
+                    
+                    return out.toByteArray()
+                }
+                
+                static void main(String[] args) {
+                    new Test1().p()
+                }
+                
+                interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
+            }
+        ''')
+
+        assert errMsg.contains('tests.lambda.Test1')
+    }
+
 
     void testDeserialize2() {
         assertScript '''
         import java.util.function.Function
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             static byte[] p() {
                     def out = new ByteArrayOutputStream()
                     out.withObjectOutputStream {
@@ -1067,8 +1155,7 @@
         import java.util.function.Function
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             byte[] p() {
                     def out = new ByteArrayOutputStream()
                     out.withObjectOutputStream {
@@ -1098,8 +1185,7 @@
         import java.util.function.Function
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             byte[] p() {
                     def out = new ByteArrayOutputStream()
                     String c = 'a'
@@ -1153,7 +1239,7 @@
         '''
     }
 
-    void testDeserialize6() {
+    void testDeserialize6InstanceFields() {
         assertScript '''
         package tests.lambda
         import java.util.function.Function
@@ -1185,7 +1271,105 @@
         '''
     }
 
-    void testDeserialize7() {
+    void testDeserialize6InstanceFieldsShouldFail() {
+        def errMsg = shouldFail(NotSerializableException, '''
+        package tests.lambda
+        import java.util.function.Function
+        
+        @groovy.transform.CompileStatic
+        class Test1 {
+            private String c = 'a'
+            
+            byte[] p() {
+                    def out = new ByteArrayOutputStream()
+                    SerializableFunction<Integer, String> f = (Integer e) -> c + e
+                    out.withObjectOutputStream {
+                        it.writeObject(f)
+                    }
+                    
+                    return out.toByteArray()
+            }
+            
+            static void main(String[] args) {
+                new ByteArrayInputStream(new Test1().p()).withObjectInputStream(Test1.class.classLoader) {
+                    SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
+                    assert 'a1' == f.apply(1)
+                }
+            }
+            
+            interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
+        }
+        ''')
+
+        assert errMsg.contains('tests.lambda.Test1')
+    }
+
+    void testDeserialize6InstanceMethods() {
+        assertScript '''
+        package tests.lambda
+        import java.util.function.Function
+        
+        @groovy.transform.CompileStatic
+        class Test1 implements Serializable {
+            private static final long serialVersionUID = -1L;
+            private String c() { 'a' }
+            
+            byte[] p() {
+                    def out = new ByteArrayOutputStream()
+                    SerializableFunction<Integer, String> f = (Integer e) -> c() + e
+                    out.withObjectOutputStream {
+                        it.writeObject(f)
+                    }
+                    
+                    return out.toByteArray()
+            }
+            
+            static void main(String[] args) {
+                new ByteArrayInputStream(new Test1().p()).withObjectInputStream(Test1.class.classLoader) {
+                    SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
+                    assert 'a1' == f.apply(1)
+                }
+            }
+            
+            interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
+        }
+        '''
+    }
+
+    void testDeserialize6InstanceMethodsShouldFail() {
+        def errMsg = shouldFail(NotSerializableException, '''
+        package tests.lambda
+        import java.util.function.Function
+        
+        @groovy.transform.CompileStatic
+        class Test1 {
+            private String c() { 'a' }
+            
+            byte[] p() {
+                    def out = new ByteArrayOutputStream()
+                    SerializableFunction<Integer, String> f = (Integer e) -> c() + e
+                    out.withObjectOutputStream {
+                        it.writeObject(f)
+                    }
+                    
+                    return out.toByteArray()
+            }
+            
+            static void main(String[] args) {
+                new ByteArrayInputStream(new Test1().p()).withObjectInputStream(Test1.class.classLoader) {
+                    SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
+                    assert 'a1' == f.apply(1)
+                }
+            }
+            
+            interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
+        }
+        ''')
+
+        assert errMsg.contains('tests.lambda.Test1')
+    }
+
+    void testDeserialize7StaticFields() {
         assertScript '''
         package tests.lambda
         import java.util.function.Function
@@ -1215,6 +1399,37 @@
         '''
     }
 
+
+    void testDeserialize7StaticMethods() {
+        assertScript '''
+        package tests.lambda
+        import java.util.function.Function
+        
+        @groovy.transform.CompileStatic
+        class Test1 {
+            private static String c() { 'a' }
+            static byte[] p() {
+                    def out = new ByteArrayOutputStream()
+                    SerializableFunction<Integer, String> f = (Integer e) -> c() + e
+                    out.withObjectOutputStream {
+                        it.writeObject(f)
+                    }
+                    
+                    return out.toByteArray()
+            }
+            
+            static void main(String[] args) {
+                new ByteArrayInputStream(Test1.p()).withObjectInputStream(Test1.class.classLoader) {
+                    SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
+                    assert 'a1' == f.apply(1)
+                }
+            }
+            
+            interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
+        }
+        '''
+    }
+
     void testDeserializeNestedLambda() {
         assertScript '''
         import java.util.function.Function
@@ -1222,8 +1437,7 @@
         interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             def p() {
                     def out1 = new ByteArrayOutputStream()
                     SerializableFunction<Integer, String> f1 = (Integer e) -> 'a' + e
@@ -1279,8 +1493,7 @@
         interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             def p() {
                     def out1 = new ByteArrayOutputStream()
                     out1.withObjectOutputStream {
@@ -1336,8 +1549,7 @@
         interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
         
         @groovy.transform.CompileStatic
-        class Test1 implements Serializable {
-            private static final long serialVersionUID = -1L;
+        class Test1 {
             static p() {
                     def out1 = new ByteArrayOutputStream()
                     out1.withObjectOutputStream {
@@ -1441,4 +1653,5 @@
         }
         '''
     }
+
 }