From db8d285b25b0f4de00acc03433d5189904c69fea Mon Sep 17 00:00:00 2001
From: Evgeny Gerashchenko <Evgeny.Gerashchenko@jetbrains.com>
Date: Wed, 17 Apr 2013 20:10:00 +0400
Subject: [PATCH] Extracted method recreating type parameters.

---
 .../java/sam/SingleAbstractMethodUtils.java   | 63 ++++++++++++-------
 1 file changed, 42 insertions(+), 21 deletions(-)

diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
index ac2e63af270..efaced7c563 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.sam;
 
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
@@ -94,36 +95,21 @@ public class SingleAbstractMethodUtils {
                 CallableMemberDescriptor.Kind.SYNTHESIZED
         );
 
-        Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> traitToFunTypeParameters =
-                SignaturesUtil.recreateTypeParametersAndReturnMapping(samInterface.getTypeConstructor().getParameters(), result);
-        TypeSubstitutor typeParametersSubstitutor = SignaturesUtil.createSubstitutorForTypeParameters(traitToFunTypeParameters);
+        TypeParameters typeParameters = recreateAndInitializeTypeParameters(samInterface.getTypeConstructor().getParameters(), result);
 
         JetType parameterTypeUnsubstituted = getFunctionTypeForSamType(samInterface.getDefaultType());
-        JetType parameterType = typeParametersSubstitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
-        assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParametersSubstitutor;
+        JetType parameterType = typeParameters.substitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
+        assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParameters.substitutor;
         ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl(
                 result, 0, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("function"), parameterType, false, null);
 
-        JetType returnType = typeParametersSubstitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE);
-        assert returnType != null : "couldn't substitute type: " + returnType + ", substitutor = " + typeParametersSubstitutor;
-
-        for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> mapEntry : traitToFunTypeParameters.entrySet()) {
-            TypeParameterDescriptor traitTypeParameter = mapEntry.getKey();
-            TypeParameterDescriptorImpl funTypeParameter = mapEntry.getValue();
-
-            for (JetType upperBound : traitTypeParameter.getUpperBounds()) {
-                JetType upperBoundSubstituted = typeParametersSubstitutor.substitute(upperBound, Variance.INVARIANT);
-                assert upperBoundSubstituted != null : "couldn't substitute type: " + upperBound + ", substitutor = " + typeParametersSubstitutor;
-                funTypeParameter.addUpperBound(upperBoundSubstituted);
-            }
-
-            funTypeParameter.setInitialized();
-        }
+        JetType returnType = typeParameters.substitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE);
+        assert returnType != null : "couldn't substitute type: " + returnType + ", substitutor = " + typeParameters.substitutor;
 
         result.initialize(
                 null,
                 null,
-                Lists.newArrayList(traitToFunTypeParameters.values()),
+                typeParameters.descriptors,
                 Arrays.asList(parameter),
                 returnType,
                 Modality.FINAL,
@@ -185,6 +171,31 @@ public class SingleAbstractMethodUtils {
         return result;
     }
 
+    @NotNull
+    private static TypeParameters recreateAndInitializeTypeParameters(
+            @NotNull List<TypeParameterDescriptor> originalParameters,
+            @Nullable DeclarationDescriptor newOwner
+    ) {
+        Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> traitToFunTypeParameters =
+                SignaturesUtil.recreateTypeParametersAndReturnMapping(originalParameters, newOwner);
+        TypeSubstitutor typeParametersSubstitutor = SignaturesUtil.createSubstitutorForTypeParameters(traitToFunTypeParameters);
+        for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> mapEntry : traitToFunTypeParameters.entrySet()) {
+            TypeParameterDescriptor traitTypeParameter = mapEntry.getKey();
+            TypeParameterDescriptorImpl funTypeParameter = mapEntry.getValue();
+
+            for (JetType upperBound : traitTypeParameter.getUpperBounds()) {
+                JetType upperBoundSubstituted = typeParametersSubstitutor.substitute(upperBound, Variance.INVARIANT);
+                assert upperBoundSubstituted != null : "couldn't substitute type: " + upperBound + ", substitutor = " + typeParametersSubstitutor;
+                funTypeParameter.addUpperBound(upperBoundSubstituted);
+            }
+
+            funTypeParameter.setInitialized();
+        }
+
+        List<TypeParameterDescriptor> typeParameters = Lists.<TypeParameterDescriptor>newArrayList(traitToFunTypeParameters.values());
+        return new TypeParameters(typeParameters, typeParametersSubstitutor);
+    }
+
     @NotNull
     public static SimpleFunctionDescriptor getAbstractMethodOfSamType(@NotNull JetType type) {
         return (SimpleFunctionDescriptor) getAbstractMembers(type).get(0);
@@ -197,4 +208,14 @@ public class SingleAbstractMethodUtils {
 
     private SingleAbstractMethodUtils() {
     }
+
+    private static class TypeParameters {
+        public final List<TypeParameterDescriptor> descriptors;
+        public final TypeSubstitutor substitutor;
+
+        private TypeParameters(List<TypeParameterDescriptor> descriptors, TypeSubstitutor substitutor) {
+            this.descriptors = descriptors;
+            this.substitutor = substitutor;
+        }
+    }
 }