few method extracted from too complex method

.idea/inspectionProfiles/idea_default.xml

@@ -410,9 +410,6 @@
     <inspection_tool class="UtilityClassWithPublicConstructor" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="UtilityClassWithoutPrivateConstructor" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ignoreClassesWithOnlyMain" value="false" />
-      <option name="ignorableAnnotations">
-        <value />
-      </option>
     </inspection_tool>
     <inspection_tool class="VolatileLongOrDoubleField" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="WaitNotInLoop" enabled="true" level="WARNING" enabled_by_default="true" />

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -425,30 +425,18 @@ public class FunctionCodegen {
     ) {
         DeclarationDescriptor contextClass = owner.getContextDescriptor().getContainingDeclaration();
 
-        if (kind != OwnerKind.TRAIT_IMPL) {
+        if (kind != OwnerKind.TRAIT_IMPL &&
-            // we don't generate defaults for traits but do for traitImpl
+            contextClass instanceof ClassDescriptor &&
-            if (contextClass instanceof ClassDescriptor) {
+            ((ClassDescriptor) contextClass).getKind() == ClassKind.TRAIT) {
-                PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(state.getBindingContext(), contextClass);
-                if (psiElement instanceof JetClass) {
-                    JetClass element = (JetClass) psiElement;
-                    if (element.isTrait()) {
             return;
         }
-                }
+
-            }
+        boolean needed = isDefaultNeeded(functionDescriptor);
+
+        if (!needed) {
+            return;
         }
 
-        boolean needed = false;
-        if (functionDescriptor != null) {
-            for (ValueParameterDescriptor parameterDescriptor : functionDescriptor.getValueParameters()) {
-                if (parameterDescriptor.declaresDefaultValue()) {
-                    needed = true;
-                    break;
-                }
-            }
-        }
-
-        if (needed) {
         ReceiverDescriptor receiverParameter = functionDescriptor.getReceiverParameter();
         boolean hasReceiver = receiverParameter.exists();
         boolean isStatic = kind == OwnerKind.NAMESPACE || kind instanceof OwnerKind.StaticDelegateKind;
@@ -483,6 +471,26 @@ public class FunctionCodegen {
             StubCodegen.generateStubCode(mv);
         }
         else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
+            generateDefaultImpl(owner, state, jvmSignature, functionDescriptor, kind, receiverParameter, hasReceiver, isStatic,
+                                ownerInternalName,
+                                isConstructor, mv, iv);
+        }
+    }
+
+    private static void generateDefaultImpl(
+            CodegenContexts.MethodContext owner,
+            GenerationState state,
+            Method jvmSignature,
+            FunctionDescriptor functionDescriptor,
+            OwnerKind kind,
+            ReceiverDescriptor receiverParameter,
+            boolean hasReceiver,
+            boolean aStatic,
+            JvmClassName ownerInternalName,
+            boolean constructor,
+            MethodVisitor mv,
+            InstructionAdapter iv
+    ) {
         mv.visitCode();
 
         FrameMap frameMap = owner.prepareFrame(state.getInjector().getJetTypeMapper());
@@ -494,7 +502,7 @@ public class FunctionCodegen {
         ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), owner, state);
 
         int var = 0;
-                if (!isStatic) {
+        if (!aStatic) {
             var++;
         }
 
@@ -519,7 +527,7 @@ public class FunctionCodegen {
         int maskIndex = var;
 
         var = 0;
-                if (!isStatic) {
+        if (!aStatic) {
             mv.visitVarInsn(ALOAD, var++);
         }
 
@@ -561,21 +569,24 @@ public class FunctionCodegen {
             var += t.getSize();
         }
 
-                if (!isStatic) {
+        final String internalName = ownerInternalName.getInternalName();
+        final String jvmSignatureName = jvmSignature.getName();
+        final String jvmSignatureDescriptor = jvmSignature.getDescriptor();
+        if (!aStatic) {
             if (kind == OwnerKind.TRAIT_IMPL) {
-                        iv.invokeinterface(ownerInternalName.getInternalName(), jvmSignature.getName(), jvmSignature.getDescriptor());
+                iv.invokeinterface(internalName, jvmSignatureName, jvmSignatureDescriptor);
             }
             else {
-                        if (!isConstructor) {
+                if (!constructor) {
-                            iv.invokevirtual(ownerInternalName.getInternalName(), jvmSignature.getName(), jvmSignature.getDescriptor());
+                    iv.invokevirtual(internalName, jvmSignatureName, jvmSignatureDescriptor);
                 }
                 else {
-                            iv.invokespecial(ownerInternalName.getInternalName(), jvmSignature.getName(), jvmSignature.getDescriptor());
+                    iv.invokespecial(internalName, jvmSignatureName, jvmSignatureDescriptor);
                 }
             }
         }
         else {
-                    iv.invokestatic(ownerInternalName.getInternalName(), jvmSignature.getName(), jvmSignature.getDescriptor());
+            iv.invokestatic(internalName, jvmSignatureName, jvmSignatureDescriptor);
         }
 
         iv.areturn(jvmSignature.getReturnType());
@@ -584,8 +595,19 @@ public class FunctionCodegen {
                  BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
         mv.visitEnd();
     }
+
+    private static boolean isDefaultNeeded(FunctionDescriptor functionDescriptor) {
+        boolean needed = false;
+        if (functionDescriptor != null) {
+            for (ValueParameterDescriptor parameterDescriptor : functionDescriptor.getValueParameters()) {
+                if (parameterDescriptor.declaresDefaultValue()) {
+                    needed = true;
+                    break;
                 }
             }
+        }
+        return needed;
+    }
 
     private static boolean differentMethods(Method method, Method overridden) {
         if (!method.getReturnType().equals(overridden.getReturnType())) {