From cb6ddc5db3a932db492c1c393d09f07393e90be4 Mon Sep 17 00:00:00 2001
From: Dmitry Jemerov <yole@jetbrains.com>
Date: Mon, 1 Jun 2015 21:34:47 +0200
Subject: [PATCH] correctly check if we need to process deferred types in body
 resolver

---
 .../kotlin/resolve/BodyResolver.java          | 45 ++++++++++---------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
index 2bf35337124..337c924b07b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
@@ -511,7 +511,8 @@ public class BodyResolver {
             AnnotationResolver.resolveAnnotationsArguments(klass.getPrimaryConstructorModifierList(), trace);
 
             if (unsubstitutedPrimaryConstructor != null) {
-                WritableScope parameterScope = getPrimaryConstructorParametersScope(classDescriptor.getScopeForClassHeaderResolution(), unsubstitutedPrimaryConstructor);
+                WritableScope parameterScope = getPrimaryConstructorParametersScope(classDescriptor.getScopeForClassHeaderResolution(),
+                                                                                    unsubstitutedPrimaryConstructor);
                 valueParameterResolver.resolveValueParameters(klass.getPrimaryConstructorParameters(), unsubstitutedPrimaryConstructor.getValueParameters(),
                                        parameterScope, c.getOuterDataFlowInfo(), trace);
             }
@@ -799,30 +800,30 @@ public class BodyResolver {
 
     private void computeDeferredTypes() {
         Collection<Box<DeferredType>> deferredTypes = trace.getKeys(DEFERRED_TYPE);
-        if (deferredTypes != null) {
-            // +1 is a work around agains new Queue(0).addLast(...) bug // stepan.koltsov@ 2011-11-21
-            final Queue<DeferredType> queue = new Queue<DeferredType>(deferredTypes.size() + 1);
-            trace.addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<Box<DeferredType>, Boolean>() {
-                @Override
-                public void handleRecord(WritableSlice<Box<DeferredType>, Boolean> deferredTypeKeyDeferredTypeWritableSlice, Box<DeferredType> key, Boolean value) {
-                    queue.addLast(key.getData());
-                }
-            });
-            for (Box<DeferredType> deferredType : deferredTypes) {
-                queue.addLast(deferredType.getData());
+        if (deferredTypes.isEmpty()) {
+            return;
+        }
+        // +1 is a work around against new Queue(0).addLast(...) bug // stepan.koltsov@ 2011-11-21
+        final Queue<DeferredType> queue = new Queue<DeferredType>(deferredTypes.size() + 1);
+        trace.addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<Box<DeferredType>, Boolean>() {
+            @Override
+            public void handleRecord(WritableSlice<Box<DeferredType>, Boolean> deferredTypeKeyDeferredTypeWritableSlice, Box<DeferredType> key, Boolean value) {
+                queue.addLast(key.getData());
             }
-            while (!queue.isEmpty()) {
-                DeferredType deferredType = queue.pullFirst();
-                if (!deferredType.isComputed()) {
-                    try {
-                        deferredType.getDelegate(); // to compute
-                    }
-                    catch (ReenteringLazyValueComputationException e) {
-                        // A problem should be reported while computing the type
-                    }
+        });
+        for (Box<DeferredType> deferredType : deferredTypes) {
+            queue.addLast(deferredType.getData());
+        }
+        while (!queue.isEmpty()) {
+            DeferredType deferredType = queue.pullFirst();
+            if (!deferredType.isComputed()) {
+                try {
+                    deferredType.getDelegate(); // to compute
+                }
+                catch (ReenteringLazyValueComputationException e) {
+                    // A problem should be reported while computing the type
                 }
             }
         }
     }
-
 }