JavaClassDescriptor interface extracted

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

@@ -52,7 +52,7 @@ import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.*;
@@ -248,7 +248,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 if (constant != null) {
                     return StackValue.constant(constant.getValue(), expressionType(expression));
                 }
-                ClassDescriptorFromJvmBytecode samInterface = bindingContext.get(CodegenBinding.SAM_VALUE, expression);
+                JavaClassDescriptor samInterface = bindingContext.get(CodegenBinding.SAM_VALUE, expression);
                 if (samInterface != null) {
                     return genSamInterfaceValue(expression, samInterface, visitor);
                 }
@@ -1922,7 +1922,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     private StackValue invokeSamConstructor(
             JetCallExpression expression,
             ResolvedCall<? extends CallableDescriptor> resolvedCall,
-            ClassDescriptorFromJvmBytecode samInterface
+            JavaClassDescriptor samInterface
     ) {
         ResolvedValueArgument argument = resolvedCall.getValueArgumentsByIndex().get(0);
         if (!(argument instanceof ExpressionValueArgument)) {
@@ -1939,7 +1939,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     private StackValue genSamInterfaceValue(
             @NotNull JetExpression expression,
-            @NotNull ClassDescriptorFromJvmBytecode samInterface,
+            @NotNull JavaClassDescriptor samInterface,
             @NotNull JetVisitor<StackValue, StackValue> visitor
     ) {
         if (expression instanceof JetFunctionLiteralExpression) {

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

@@ -24,21 +24,21 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 
 import java.util.Map;
 
 public class SamWrapperClasses {
     private final GenerationState state;
 
-    private final Map<Pair<ClassDescriptorFromJvmBytecode, JetFile>, Type> samInterfaceToWrapperClass = Maps.newHashMap();
+    private final Map<Pair<JavaClassDescriptor, JetFile>, Type> samInterfaceToWrapperClass = Maps.newHashMap();
 
     public SamWrapperClasses(GenerationState state) {
         this.state = state;
     }
 
     @NotNull
-    public Type getSamWrapperClass(@NotNull final ClassDescriptorFromJvmBytecode samInterface, @NotNull final JetFile file) {
+    public Type getSamWrapperClass(@NotNull final JavaClassDescriptor samInterface, @NotNull final JetFile file) {
         return ContainerUtil.getOrCreate(samInterfaceToWrapperClass, Pair.create(samInterface, file),
                                          new Factory<Type>() {
                                              @Override

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

@@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -45,11 +45,11 @@ import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE;
 public class SamWrapperCodegen extends ParentCodegenAwareImpl {
     private static final String FUNCTION_FIELD_NAME = "function";
 
-    @NotNull private final ClassDescriptorFromJvmBytecode samInterface;
+    @NotNull private final JavaClassDescriptor samInterface;
 
     public SamWrapperCodegen(
             @NotNull GenerationState state,
-            @NotNull ClassDescriptorFromJvmBytecode samInterface,
+            @NotNull JavaClassDescriptor samInterface,
             @Nullable MemberCodegen parentCodegen
     ) {
         super(state, parentCodegen);

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

@@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -372,7 +372,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         }
         List<ResolvedValueArgument> valueArguments = call.getValueArgumentsByIndex();
         for (ValueParameterDescriptor valueParameter : original.getValueParameters()) {
-            ClassDescriptorFromJvmBytecode samInterface = getInterfaceIfSamType(valueParameter.getType());
+            JavaClassDescriptor samInterface = getInterfaceIfSamType(valueParameter.getType());
             if (samInterface == null) {
                 continue;
             }
@@ -399,7 +399,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter(operationDescriptor);
         if (original == null) return;
 
-        ClassDescriptorFromJvmBytecode samInterfaceOfParameter = getInterfaceIfSamType(original.getValueParameters().get(0).getType());
+        JavaClassDescriptor samInterfaceOfParameter = getInterfaceIfSamType(original.getValueParameters().get(0).getType());
         if (samInterfaceOfParameter == null) return;
 
         IElementType token = expression.getOperationToken();
@@ -429,7 +429,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         List<JetExpression> indexExpressions = expression.getIndexExpressions();
         List<ValueParameterDescriptor> parameters = original.getValueParameters();
         for (ValueParameterDescriptor valueParameter : parameters) {
-            ClassDescriptorFromJvmBytecode samInterface = getInterfaceIfSamType(valueParameter.getType());
+            JavaClassDescriptor samInterface = getInterfaceIfSamType(valueParameter.getType());
             if (samInterface == null) {
                 continue;
             }
@@ -449,12 +449,12 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Nullable
-    private static ClassDescriptorFromJvmBytecode getInterfaceIfSamType(@NotNull JetType originalType) {
+    private static JavaClassDescriptor getInterfaceIfSamType(@NotNull JetType originalType) {
         if (!SingleAbstractMethodUtils.isSamType(originalType)) {
             return null;
         }
-        ClassDescriptorFromJvmBytecode samInterface =
+        JavaClassDescriptor samInterface =
-                (ClassDescriptorFromJvmBytecode) originalType.getConstructor().getDeclarationDescriptor();
+                (JavaClassDescriptor) originalType.getConstructor().getDeclarationDescriptor();
         assert samInterface != null;
         return samInterface;
     }

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

@@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -57,7 +57,7 @@ public class CodegenBinding {
 
     public static final WritableSlice<ClassDescriptor, Collection<ClassDescriptor>> INNER_CLASSES = Slices.createSimpleSlice();
 
-    public static final WritableSlice<JetExpression, ClassDescriptorFromJvmBytecode> SAM_VALUE = Slices.createSimpleSlice();
+    public static final WritableSlice<JetExpression, JavaClassDescriptor> SAM_VALUE = Slices.createSimpleSlice();
 
     private CodegenBinding() {
     }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java

@@ -31,7 +31,7 @@ import java.util.Collection;
 /**
  * @see org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor
  */
-public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite {
+public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite implements JavaClassDescriptor {
     private JetType functionTypeForSamInterface;
     private JavaClassNonStaticMembersScope scopeForConstructorResolve;
     private ConstructorDescriptor primaryConstructor;
@@ -77,6 +77,7 @@ public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite {
         this.scopeForConstructorResolve = scopeForConstructorResolve;
     }
 
+    @Override
     @Nullable
     public JetType getFunctionTypeForSamInterface() {
         return functionTypeForSamInterface;

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaClassDescriptor.java

@@ -0,0 +1,26 @@
+/*
+ * 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.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+
+public interface JavaClassDescriptor extends ClassDescriptor {
+    @Nullable
+    JetType getFunctionTypeForSamInterface();
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/SamConstructorDescriptor.java

@@ -22,12 +22,12 @@ import org.jetbrains.jet.lang.descriptors.SynthesizedCallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 
 public class SamConstructorDescriptor extends SimpleFunctionDescriptorImpl
-        implements SynthesizedCallableMemberDescriptor<ClassDescriptorFromJvmBytecode> {
+        implements SynthesizedCallableMemberDescriptor<JavaClassDescriptor> {
-    private final ClassDescriptorFromJvmBytecode samInterface;
+    private final JavaClassDescriptor samInterface;
 
     public SamConstructorDescriptor(
             @NotNull ClassOrNamespaceDescriptor containingDeclaration,
-            @NotNull ClassDescriptorFromJvmBytecode samInterface
+            @NotNull JavaClassDescriptor samInterface
     ) {
         super(containingDeclaration, samInterface.getAnnotations(), samInterface.getName(), Kind.SYNTHESIZED);
         this.samInterface = samInterface;
@@ -35,7 +35,7 @@ public class SamConstructorDescriptor extends SimpleFunctionDescriptorImpl
 
     @NotNull
     @Override
-    public ClassDescriptorFromJvmBytecode getBaseForSynthesized() {
+    public JavaClassDescriptor getBaseForSynthesized() {
         return samInterface;
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinder;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaEnumClassObjectDescriptor;
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
@@ -237,7 +238,7 @@ public final class JavaClassResolver {
     }
 
     @NotNull
-    private ClassDescriptorFromJvmBytecode doCreateClassDescriptor(
+    private JavaClassDescriptor doCreateClassDescriptor(
             @NotNull FqName fqName,
             @NotNull JavaClass javaClass,
             @NotNull PostponedTasks taskList,
@@ -313,7 +314,7 @@ public final class JavaClassResolver {
     @NotNull
     private SimpleFunctionDescriptor resolveFunctionOfSamInterface(
             @NotNull JavaMethod samInterfaceMethod,
-            @NotNull ClassDescriptorFromJvmBytecode samInterface
+            @NotNull JavaClassDescriptor samInterface
     ) {
         JavaClass methodContainer = samInterfaceMethod.getContainingClass();
         FqName containerFqName = methodContainer.getFqName();

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor;
 import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers;
@@ -229,10 +229,10 @@ public final class JavaFunctionResolver {
     }
 
     @Nullable
-    private static ClassDescriptorFromJvmBytecode findClassInScope(@NotNull JetScope memberScope, @NotNull Name name) {
+    private static JavaClassDescriptor findClassInScope(@NotNull JetScope memberScope, @NotNull Name name) {
         ClassifierDescriptor classifier = memberScope.getClassifier(name);
-        if (classifier instanceof ClassDescriptorFromJvmBytecode) {
+        if (classifier instanceof JavaClassDescriptor) {
-            return (ClassDescriptorFromJvmBytecode) classifier;
+            return (JavaClassDescriptor) classifier;
         }
         return null;
     }
@@ -244,9 +244,9 @@ public final class JavaFunctionResolver {
     // +-- namespace Bar
     // We need to find class 'Baz' in namespace 'foo.Bar'.
     @Nullable
-    private static ClassDescriptorFromJvmBytecode findClassInNamespace(@NotNull NamespaceDescriptor namespace, @NotNull Name name) {
+    private static JavaClassDescriptor findClassInNamespace(@NotNull NamespaceDescriptor namespace, @NotNull Name name) {
         // First, try to find in namespace directly
-        ClassDescriptorFromJvmBytecode found = findClassInScope(namespace.getMemberScope(), name);
+        JavaClassDescriptor found = findClassInScope(namespace.getMemberScope(), name);
         if (found != null) {
             return found;
         }
@@ -269,7 +269,7 @@ public final class JavaFunctionResolver {
     @Nullable
     public static SamConstructorDescriptor resolveSamConstructor(@NotNull NamespaceDescriptor owner, @NotNull NamedMembers namedMembers) {
         if (namedMembers.getSamInterface() != null) {
-            ClassDescriptorFromJvmBytecode klass = findClassInNamespace(owner, namedMembers.getName());
+            JavaClassDescriptor klass = findClassInNamespace(owner, namedMembers.getName());
             if (klass != null) {
                 return createSamConstructorFunction(owner, klass);
             }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor;
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils;
@@ -89,9 +89,9 @@ public class SingleAbstractMethodUtils {
         // e.g. samType == Comparator<String>?
 
         ClassifierDescriptor classifier = samType.getConstructor().getDeclarationDescriptor();
-        if (classifier instanceof ClassDescriptorFromJvmBytecode) {
+        if (classifier instanceof JavaClassDescriptor) {
             // Function2<T, T, Int>
-            JetType functionTypeDefault = ((ClassDescriptorFromJvmBytecode) classifier).getFunctionTypeForSamInterface();
+            JetType functionTypeDefault = ((JavaClassDescriptor) classifier).getFunctionTypeForSamInterface();
 
             if (functionTypeDefault != null) {
                 // Function2<String, String, Int>?
@@ -134,7 +134,7 @@ public class SingleAbstractMethodUtils {
     @NotNull
     public static SamConstructorDescriptor createSamConstructorFunction(
             @NotNull ClassOrNamespaceDescriptor owner,
-            @NotNull ClassDescriptorFromJvmBytecode samInterface
+            @NotNull JavaClassDescriptor samInterface
     ) {
         assert isSamInterface(samInterface) : samInterface;
 

idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java

@@ -44,7 +44,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
 import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -200,8 +200,8 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         if (member instanceof PsiMethod) {
             if (((PsiMethod) member).isConstructor()) {
                 DeclarationDescriptor container = memberScope.getContainingDeclaration();
-                assert container instanceof ClassDescriptorFromJvmBytecode : container + "\n" + memberScope;
+                assert container instanceof JavaClassDescriptor : container + "\n" + memberScope;
-                ((ClassDescriptorFromJvmBytecode) container).getConstructors();
+                ((JavaClassDescriptor) container).getConstructors();
             }
             else {
                 memberScope.getFunctions(name);