Get rid of SAM_ADAPTER_FUNCTION_TO_ORIGINAL

Use SAM adapters hierarchy instead

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

@@ -2084,8 +2084,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             return typeMapper.mapToFunctionInvokeCallableMethod(createInvoke(fd));
         }
         else {
-            SimpleFunctionDescriptor originalOfSamAdapter = (SimpleFunctionDescriptor) SamCodegenUtil
+            SimpleFunctionDescriptor originalOfSamAdapter = (SimpleFunctionDescriptor) SamCodegenUtil.getOriginalIfSamAdapter(fd);
-                    .getOriginalIfSamAdapter(bindingContext, fd);
             return typeMapper.mapToCallableMethod(originalOfSamAdapter != null ? originalOfSamAdapter : fd, superCall,
                                                   isCallInsideSameClassAsDeclared(fd, context),
                                                   isCallInsideSameModuleAsDeclared(fd, context),
@@ -3289,8 +3288,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         //See StackValue.receiver for more info
         pushClosureOnStack(closure, resolvedCall.getThisObject().exists() || resolvedCall.getReceiverArgument().exists());
 
-        ConstructorDescriptor originalOfSamAdapter = (ConstructorDescriptor) SamCodegenUtil
+        ConstructorDescriptor originalOfSamAdapter = (ConstructorDescriptor) SamCodegenUtil.getOriginalIfSamAdapter(constructorDescriptor);
-                .getOriginalIfSamAdapter(bindingContext, constructorDescriptor);
         CallableMethod method = typeMapper.mapToCallableMethod(originalOfSamAdapter == null ? constructorDescriptor : originalOfSamAdapter);
         invokeMethodWithArguments(method, resolvedCall, null, StackValue.none());
 

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

@@ -18,30 +18,27 @@ package org.jetbrains.jet.codegen;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
 
 public class SamCodegenUtil {
     @Nullable
-    public static FunctionDescriptor getOriginalIfSamAdapter(@NotNull BindingContext bindingContext, @NotNull CallableDescriptor fun) {
+    public static FunctionDescriptor getOriginalIfSamAdapter(@NotNull FunctionDescriptor fun) {
-        if (!(fun instanceof FunctionDescriptor)) {
+        FunctionDescriptor original = fun.getOriginal();
-            return null;
+        if (original instanceof SamAdapterDescriptor<?>) {
-        }
+            return ((SamAdapterDescriptor) original).getDeclaration();
-        FunctionDescriptor original = ((FunctionDescriptor) fun).getOriginal();
-        if (original.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
-            return bindingContext.get(JavaBindingContext.SAM_ADAPTER_FUNCTION_TO_ORIGINAL, original);
         }
+
         if (original.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
             for (FunctionDescriptor overridden : original.getOverriddenDescriptors()) {
-                FunctionDescriptor originalIfSamAdapter = getOriginalIfSamAdapter(bindingContext, overridden);
+                FunctionDescriptor originalIfSamAdapter = getOriginalIfSamAdapter(overridden);
                 if (originalIfSamAdapter != null) {
                     return originalIfSamAdapter;
                 }
             }
         }
+
         return null;
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java

@@ -365,7 +365,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         if (!(descriptor instanceof FunctionDescriptor)) {
             return;
         }
-        FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter(bindingContext, descriptor);
+        FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) descriptor);
 
         if (original == null) {
             return;
@@ -396,7 +396,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
                 (FunctionDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationReference());
         if (operationDescriptor == null) return;
 
-        FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter(bindingContext, operationDescriptor);
+        FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter(operationDescriptor);
         if (original == null) return;
 
         ClassDescriptorFromJvmBytecode samInterfaceOfParameter = getInterfaceIfSamType(original.getValueParameters().get(0).getType());
@@ -421,7 +421,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         }
 
         boolean isSetter = operationDescriptor.getName().asString().equals("set");
-        FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter(bindingContext, operationDescriptor);
+        FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter(operationDescriptor);
         if (original == null) {
             return;
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -43,7 +42,6 @@ public class JavaBindingContext {
             new BasicWritableSlice<DeclarationDescriptor, List<String>>(Slices.ONLY_REWRITE_TO_EQUAL, true);
 
     public static final WritableSlice<SimpleFunctionDescriptor, ClassDescriptorFromJvmBytecode> SAM_CONSTRUCTOR_TO_INTERFACE = Slices.createSimpleSlice();
-    public static final WritableSlice<FunctionDescriptor, FunctionDescriptor> SAM_ADAPTER_FUNCTION_TO_ORIGINAL = Slices.createSimpleSlice();
 
     private JavaBindingContext() {
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/SamAdapterDescriptor.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.descriptor;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+
+public interface SamAdapterDescriptor<D extends FunctionDescriptor> extends FunctionDescriptor {
+    @NotNull
+    D getDeclaration();
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java

@@ -226,7 +226,7 @@ public final class JavaConstructorResolver {
     @Nullable
     private ConstructorDescriptor resolveSamAdapter(@NotNull ConstructorDescriptor original) {
         return isSamAdapterNecessary(original)
-               ? recordSamAdapter(original, createSamAdapterConstructor(original), trace)
+               ? (ConstructorDescriptor) recordSamAdapter(original, createSamAdapterConstructor(original), trace)
                : null;
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
 import org.jetbrains.jet.lang.resolve.java.TypeUsage;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor;
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil;
@@ -321,7 +322,7 @@ public final class JavaFunctionResolver {
     @Nullable
     private SimpleFunctionDescriptor resolveSamAdapter(@NotNull SimpleFunctionDescriptor original) {
         return isSamAdapterNecessary(original)
-               ? recordSamAdapter(original, createSamAdapterFunction(original), trace)
+               ? (SimpleFunctionDescriptor) recordSamAdapter(original, createSamAdapterFunction(original), trace)
                : null;
     }
 
@@ -388,9 +389,13 @@ public final class JavaFunctionResolver {
         return constructorFunction;
     }
 
-    static <F extends FunctionDescriptor> F recordSamAdapter(F original, F adapterFunction, BindingTrace trace) {
+    @NotNull
-        trace.record(JavaBindingContext.SAM_ADAPTER_FUNCTION_TO_ORIGINAL, adapterFunction, original);
+    /* package */ static <F extends FunctionDescriptor> SamAdapterDescriptor<F> recordSamAdapter(
-        trace.record(BindingContext.SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, adapterFunction, original);
+            @NotNull F original,
-        return adapterFunction;
+            @NotNull SamAdapterDescriptor<F> adapter,
+            @NotNull BindingTrace trace
+    ) {
+        trace.record(BindingContext.SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, adapter, original);
+        return adapter;
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SamAdapterConstructorDescriptor.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.sam;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor;
+
+/* package */ class SamAdapterConstructorDescriptor extends ConstructorDescriptorImpl
+        implements SamAdapterDescriptor<ConstructorDescriptor> {
+    private final ConstructorDescriptor declaration;
+
+    public SamAdapterConstructorDescriptor(@NotNull ConstructorDescriptor declaration) {
+        super(declaration.getContainingDeclaration(), declaration.getAnnotations(), declaration.isPrimary(), Kind.SYNTHESIZED);
+        this.declaration = declaration;
+    }
+
+    @NotNull
+    @Override
+    public ConstructorDescriptor getDeclaration() {
+        return declaration;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SamAdapterFunctionDescriptor.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.sam;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor;
+
+/* package */ class SamAdapterFunctionDescriptor extends SimpleFunctionDescriptorImpl
+        implements SamAdapterDescriptor<SimpleFunctionDescriptor> {
+    private final SimpleFunctionDescriptor declaration;
+
+    public SamAdapterFunctionDescriptor(@NotNull SimpleFunctionDescriptor declaration) {
+        super(declaration.getContainingDeclaration(), declaration.getAnnotations(), declaration.getName(), Kind.SYNTHESIZED);
+        this.declaration = declaration;
+    }
+
+    @NotNull
+    @Override
+    public SimpleFunctionDescriptor getDeclaration() {
+        return declaration;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SamAdapterOverridabilityCondition.java

@@ -56,18 +56,14 @@ public class SamAdapterOverridabilityCondition implements ExternalOverridability
             return null;
         }
 
-        SimpleFunctionDescriptor fun = declarationOrSynthesized.first;
+        SimpleFunctionDescriptorImpl fun = (SimpleFunctionDescriptorImpl) declarationOrSynthesized.first.getOriginal();
-        if (fun.getKind() != CallableMemberDescriptor.Kind.SYNTHESIZED) {
+        if (!(fun instanceof SamAdapterFunctionDescriptor)) {
             return null;
         }
 
-        SimpleFunctionDescriptor originalOfSynthesized = ((SimpleFunctionDescriptorImpl) fun.getOriginal())
+        SimpleFunctionDescriptor originalDeclarationOfSam = ((SamAdapterFunctionDescriptor) fun).getDeclaration();
-                .getOriginalOfSynthesized();
-        if (originalOfSynthesized == null) {
-            return null;
-        }
 
-        return ((SimpleFunctionDescriptor) originalOfSynthesized.substitute(TypeSubstitutor.create(declarationOrSynthesized.second)));
+        return ((SimpleFunctionDescriptor) originalDeclarationOfSam.substitute(TypeSubstitutor.create(declarationOrSynthesized.second)));
     }
 
     @Nullable

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java

@@ -22,12 +22,12 @@ 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.ConstructorDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.*;
@@ -188,15 +188,9 @@ public class SingleAbstractMethodUtils {
     }
 
     @NotNull
-    public static SimpleFunctionDescriptor createSamAdapterFunction(@NotNull final SimpleFunctionDescriptor original) {
+    public static SamAdapterDescriptor<SimpleFunctionDescriptor> createSamAdapterFunction(@NotNull final SimpleFunctionDescriptor original) {
-        final SimpleFunctionDescriptorImpl result = new SimpleFunctionDescriptorImpl(
+        final SamAdapterFunctionDescriptor result = new SamAdapterFunctionDescriptor(original);
-                original.getContainingDeclaration(),
+        return initSamAdapter(original, result, new FunctionInitializer() {
-                original.getAnnotations(),
-                original.getName(),
-                CallableMemberDescriptor.Kind.SYNTHESIZED,
-                original
-        );
-        FunctionInitializer initializer = new FunctionInitializer() {
             @Override
             public void initialize(
                     @NotNull List<TypeParameterDescriptor> typeParameters,
@@ -214,19 +208,13 @@ public class SingleAbstractMethodUtils {
                         false
                 );
             }
-        };
+        });
-        return initSamAdapter(original, result, initializer);
     }
 
     @NotNull
-    public static ConstructorDescriptor createSamAdapterConstructor(@NotNull final ConstructorDescriptor original) {
+    public static SamAdapterDescriptor<ConstructorDescriptor> createSamAdapterConstructor(@NotNull final ConstructorDescriptor original) {
-        final ConstructorDescriptorImpl result = new ConstructorDescriptorImpl(
+        final SamAdapterConstructorDescriptor result = new SamAdapterConstructorDescriptor(original);
-                original.getContainingDeclaration(),
+        return initSamAdapter(original, result, new FunctionInitializer() {
-                original.getAnnotations(),
-                original.isPrimary(),
-                CallableMemberDescriptor.Kind.SYNTHESIZED
-        );
-        FunctionInitializer initializer = new FunctionInitializer() {
             @Override
             public void initialize(
                     @NotNull List<TypeParameterDescriptor> typeParameters,
@@ -240,13 +228,13 @@ public class SingleAbstractMethodUtils {
                         original.getExpectedThisObject() == ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER
                 );
             }
-        };
+        });
-        return initSamAdapter(original, result, initializer);
     }
 
-    private static <F extends FunctionDescriptor> F initSamAdapter(
+    @NotNull
+    private static <F extends FunctionDescriptor> SamAdapterDescriptor<F> initSamAdapter(
             @NotNull F original,
-            @NotNull F adapter,
+            @NotNull SamAdapterDescriptor<F> adapter,
             @NotNull FunctionInitializer initializer
     ) {
         TypeParameters typeParameters = recreateAndInitializeTypeParameters(original.getTypeParameters(), adapter);
@@ -276,6 +264,7 @@ public class SingleAbstractMethodUtils {
         }
 
         initializer.initialize(typeParameters.descriptors, valueParameters, returnType);
+
         return adapter;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/SimpleFunctionDescriptorImpl.java

@@ -30,29 +30,13 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
 
     private boolean isInline = false;
 
-    private final SimpleFunctionDescriptor originalOfSynthesized; // TODO replace with user data
-
     public SimpleFunctionDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull Name name,
             @NotNull Kind kind
-    ) {
-        this(containingDeclaration, annotations, name, kind, null);
-    }
-
-    public SimpleFunctionDescriptorImpl(
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull List<AnnotationDescriptor> annotations,
-            @NotNull Name name,
-            @NotNull Kind kind,
-            @Nullable SimpleFunctionDescriptor originalOfSynthesized
     ) {
         super(containingDeclaration, annotations, name, kind);
-        this.originalOfSynthesized = originalOfSynthesized;
-        if (originalOfSynthesized != null) {
-            assert kind == Kind.SYNTHESIZED;
-        }
     }
 
     private SimpleFunctionDescriptorImpl(
@@ -62,7 +46,6 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
             @NotNull Name name,
             @NotNull Kind kind) {
         super(containingDeclaration, original, annotations, name, kind);
-        originalOfSynthesized = null;
     }
 
     public SimpleFunctionDescriptorImpl initialize(
@@ -118,10 +101,4 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
     public boolean isInline() {
         return isInline;
     }
-
-    // TODO replace with user data
-    @Nullable
-    public SimpleFunctionDescriptor getOriginalOfSynthesized() {
-        return originalOfSynthesized;
-    }
 }