Move JavaDescriptorResolverData inner classes to upper level of new data package, remove JavaDescriptorResolverData itself

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

@@ -22,6 +22,9 @@ import com.intellij.psi.PsiModifierListOwner;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverNamespaceData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper;
@@ -55,11 +58,11 @@ public final class DescriptorResolverUtils {
         return kind == ClassKind.CLASS || kind == ClassKind.TRAIT || kind == ClassKind.ENUM_CLASS;
     }
 
-    public static Collection<JetType> getSupertypes(JavaDescriptorResolveData.ResolverScopeData scope) {
+    public static Collection<JetType> getSupertypes(ResolverScopeData scope) {
-        if (scope instanceof JavaDescriptorResolveData.ResolverClassData) {
+        if (scope instanceof ResolverClassData) {
-            return ((JavaDescriptorResolveData.ResolverClassData) scope).getClassDescriptor().getSupertypes();
+            return ((ResolverClassData) scope).getClassDescriptor().getSupertypes();
         }
-        else if (scope instanceof JavaDescriptorResolveData.ResolverNamespaceData) {
+        else if (scope instanceof ResolverNamespaceData) {
             return Collections.emptyList();
         }
         else {
@@ -118,7 +121,7 @@ public final class DescriptorResolverUtils {
         return null;
     }
 
-    public static void getResolverScopeData(@NotNull JavaDescriptorResolveData.ResolverScopeData scopeData) {
+    public static void getResolverScopeData(@NotNull ResolverScopeData scopeData) {
         if (scopeData.getNamedMembersMap() == null) {
             scopeData.setNamedMembersMap(JavaDescriptorResolverHelper.getNamedMembers(scopeData));
         }

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

@@ -1,227 +0,0 @@
-/*
- * Copyright 2010-2012 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;
-
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
-
-import java.util.Map;
-
-public class JavaDescriptorResolveData {
-    public static abstract class ResolverScopeData {
-        @Nullable
-        public PsiClass getPsiClass() {
-            return psiClass;
-        }
-
-        @Nullable
-        public PsiPackage getPsiPackage() {
-            return psiPackage;
-        }
-
-        @Nullable
-        public FqName getFqName() {
-            return fqName;
-        }
-
-        public boolean isStaticMembers() {
-            return staticMembers;
-        }
-
-        public boolean isKotlin() {
-            return kotlin;
-        }
-
-        public ClassOrNamespaceDescriptor getClassOrNamespaceDescriptor() {
-            return classOrNamespaceDescriptor;
-        }
-
-        @Nullable
-        private final PsiClass psiClass;
-        @Nullable
-        private final PsiPackage psiPackage;
-        @Nullable
-        private final FqName fqName;
-        private final boolean staticMembers;
-        private final boolean kotlin;
-        private final ClassOrNamespaceDescriptor classOrNamespaceDescriptor;
-
-        protected ResolverScopeData(
-                @Nullable PsiClass psiClass,
-                @Nullable PsiPackage psiPackage,
-                @Nullable FqName fqName,
-                boolean staticMembers,
-                @NotNull ClassOrNamespaceDescriptor descriptor
-        ) {
-            DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
-
-            this.psiClass = psiClass;
-            this.psiPackage = psiPackage;
-            this.fqName = fqName;
-
-            if (psiClass == null && psiPackage == null) {
-                throw new IllegalStateException("both psiClass and psiPackage cannot be null");
-            }
-
-            this.staticMembers = staticMembers;
-            this.kotlin = psiClass != null && DescriptorResolverUtils.isKotlinClass(psiClass);
-            classOrNamespaceDescriptor = descriptor;
-
-            if (fqName != null && fqName.lastSegmentIs(Name.identifier(JvmAbi.PACKAGE_CLASS)) && psiClass != null && kotlin) {
-                throw new IllegalStateException("Kotlin namespace cannot have last segment " + JvmAbi.PACKAGE_CLASS + ": " + fqName);
-            }
-        }
-
-        protected ResolverScopeData(boolean negative) {
-            if (!negative) {
-                throw new IllegalStateException();
-            }
-            this.psiClass = null;
-            this.psiPackage = null;
-            this.fqName = null;
-            this.staticMembers = false;
-            this.kotlin = false;
-            this.classOrNamespaceDescriptor = null;
-        }
-
-        @NotNull
-        public PsiElement getPsiPackageOrPsiClass() {
-            if (psiPackage != null) {
-                return psiPackage;
-            }
-            else {
-                assert psiClass != null;
-                return psiClass;
-            }
-        }
-
-        private Map<Name, NamedMembers> namedMembersMap;
-
-        public Map<Name, NamedMembers> getNamedMembersMap() {
-            return namedMembersMap;
-        }
-
-        void setNamedMembersMap(Map<Name, NamedMembers> namedMembersMap) {
-            this.namedMembersMap = namedMembersMap;
-        }
-    }
-
-    /**
-     * Class with instance members
-     */
-    public static class ResolverBinaryClassData extends ResolverClassData {
-
-        public ResolverBinaryClassData(
-                @NotNull PsiClass psiClass,
-                @Nullable FqName fqName,
-                @NotNull ClassDescriptorFromJvmBytecode classDescriptor
-        ) {
-            super(psiClass, null, fqName, false, classDescriptor);
-        }
-
-        ResolverBinaryClassData(boolean negative) {
-            super(negative);
-        }
-
-        public static final ResolverClassData NEGATIVE = new ResolverBinaryClassData(true);
-    }
-
-    public static class ResolverClassData extends ResolverScopeData {
-
-        private final ClassDescriptorFromJvmBytecode classDescriptor;
-
-        protected ResolverClassData(boolean negative) {
-            super(negative);
-            this.classDescriptor = null;
-        }
-
-        protected ResolverClassData(
-                @Nullable PsiClass psiClass,
-                @Nullable PsiPackage psiPackage,
-                @Nullable FqName fqName,
-                boolean staticMembers,
-                @NotNull ClassDescriptorFromJvmBytecode descriptor
-        ) {
-            super(psiClass, psiPackage, fqName, staticMembers, descriptor);
-            classDescriptor = descriptor;
-        }
-
-
-        public ClassDescriptorFromJvmBytecode getClassDescriptor() {
-            return classDescriptor;
-        }
-    }
-
-
-    public static class ResolverSyntheticClassObjectClassData extends ResolverClassData {
-
-        public ResolverSyntheticClassObjectClassData(
-                @Nullable PsiClass psiClass,
-                @Nullable FqName fqName,
-                @NotNull ClassDescriptorFromJvmBytecode descriptor
-        ) {
-            super(psiClass, null, fqName, true, descriptor);
-        }
-    }
-
-    /**
-     * Either package or class with static members
-     */
-    public static class ResolverNamespaceData extends ResolverScopeData {
-        public static final ResolverNamespaceData NEGATIVE = new ResolverNamespaceData(true);
-
-        private final NamespaceDescriptor namespaceDescriptor;
-
-        private JavaPackageScope memberScope;
-
-        public ResolverNamespaceData(
-                @Nullable PsiClass psiClass,
-                @Nullable PsiPackage psiPackage,
-                @NotNull FqName fqName,
-                @NotNull NamespaceDescriptor namespaceDescriptor
-        ) {
-            super(psiClass, psiPackage, fqName, true, namespaceDescriptor);
-            this.namespaceDescriptor = namespaceDescriptor;
-        }
-
-        private ResolverNamespaceData(boolean negative) {
-            super(negative);
-            this.namespaceDescriptor = null;
-        }
-
-        public JavaPackageScope getMemberScope() {
-            return memberScope;
-        }
-
-        public NamespaceDescriptor getNamespaceDescriptor() {
-            return namespaceDescriptor;
-        }
-
-        public void setMemberScope(JavaPackageScope memberScope) {
-            this.memberScope = memberScope;
-        }
-    }
-}

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

@@ -28,8 +28,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper;

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyNameUtils;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyParseResult;
 import org.jetbrains.jet.lang.resolve.java.wrapper.*;

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

@@ -24,7 +24,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverBinaryClassData.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2012 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.data;
+
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+/**
+ * Class with instance members
+ */
+public class ResolverBinaryClassData extends ResolverClassData {
+
+    public ResolverBinaryClassData(
+            @NotNull PsiClass psiClass,
+            @Nullable FqName fqName,
+            @NotNull ClassDescriptorFromJvmBytecode classDescriptor
+    ) {
+        super(psiClass, null, fqName, false, classDescriptor);
+    }
+
+    public ResolverBinaryClassData(boolean negative) {
+        super(negative);
+    }
+
+    public static final ResolverClassData NEGATIVE = new ResolverBinaryClassData(true);
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverClassData.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2010-2012 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.data;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiPackage;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+/**
+* @author Pavel Talanov
+*/
+public class ResolverClassData extends ResolverScopeData {
+
+    private final ClassDescriptorFromJvmBytecode classDescriptor;
+
+    public ResolverClassData(boolean negative) {
+        super(negative);
+        this.classDescriptor = null;
+    }
+
+    public ResolverClassData(
+            @Nullable PsiClass psiClass,
+            @Nullable PsiPackage psiPackage,
+            @Nullable FqName fqName,
+            boolean staticMembers,
+            @NotNull ClassDescriptorFromJvmBytecode descriptor
+    ) {
+        super(psiClass, psiPackage, fqName, staticMembers, descriptor);
+        classDescriptor = descriptor;
+    }
+
+
+    public ClassDescriptorFromJvmBytecode getClassDescriptor() {
+        return classDescriptor;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverNamespaceData.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2012 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.data;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiPackage;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+/**
+ * Either package or class with static members
+ */
+public class ResolverNamespaceData extends ResolverScopeData {
+    public static final ResolverNamespaceData NEGATIVE = new ResolverNamespaceData(true);
+
+    private final NamespaceDescriptor namespaceDescriptor;
+
+    private JavaPackageScope memberScope;
+
+    public ResolverNamespaceData(
+            @Nullable PsiClass psiClass,
+            @Nullable PsiPackage psiPackage,
+            @NotNull FqName fqName,
+            @NotNull NamespaceDescriptor namespaceDescriptor
+    ) {
+        super(psiClass, psiPackage, fqName, true, namespaceDescriptor);
+        this.namespaceDescriptor = namespaceDescriptor;
+    }
+
+    public ResolverNamespaceData(boolean negative) {
+        super(negative);
+        this.namespaceDescriptor = null;
+    }
+
+    public JavaPackageScope getMemberScope() {
+        return memberScope;
+    }
+
+    public NamespaceDescriptor getNamespaceDescriptor() {
+        return namespaceDescriptor;
+    }
+
+    public void setMemberScope(JavaPackageScope memberScope) {
+        this.memberScope = memberScope;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverScopeData.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2010-2012 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.data;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiPackage;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.NamedMembers;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+import java.util.Map;
+
+/**
+* @author Pavel Talanov
+*/
+public abstract class ResolverScopeData {
+    @Nullable
+    public PsiClass getPsiClass() {
+        return psiClass;
+    }
+
+    @Nullable
+    public PsiPackage getPsiPackage() {
+        return psiPackage;
+    }
+
+    @Nullable
+    public FqName getFqName() {
+        return fqName;
+    }
+
+    public boolean isStaticMembers() {
+        return staticMembers;
+    }
+
+    public boolean isKotlin() {
+        return kotlin;
+    }
+
+    public ClassOrNamespaceDescriptor getClassOrNamespaceDescriptor() {
+        return classOrNamespaceDescriptor;
+    }
+
+    @Nullable
+    private final PsiClass psiClass;
+    @Nullable
+    private final PsiPackage psiPackage;
+    @Nullable
+    private final FqName fqName;
+    private final boolean staticMembers;
+    private final boolean kotlin;
+    private final ClassOrNamespaceDescriptor classOrNamespaceDescriptor;
+
+    public ResolverScopeData(
+            @Nullable PsiClass psiClass,
+            @Nullable PsiPackage psiPackage,
+            @Nullable FqName fqName,
+            boolean staticMembers,
+            @NotNull ClassOrNamespaceDescriptor descriptor
+    ) {
+        DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
+
+        this.psiClass = psiClass;
+        this.psiPackage = psiPackage;
+        this.fqName = fqName;
+
+        if (psiClass == null && psiPackage == null) {
+            throw new IllegalStateException("both psiClass and psiPackage cannot be null");
+        }
+
+        this.staticMembers = staticMembers;
+        this.kotlin = psiClass != null && DescriptorResolverUtils.isKotlinClass(psiClass);
+        classOrNamespaceDescriptor = descriptor;
+
+        if (fqName != null && fqName.lastSegmentIs(Name.identifier(JvmAbi.PACKAGE_CLASS)) && psiClass != null && kotlin) {
+            throw new IllegalStateException("Kotlin namespace cannot have last segment " + JvmAbi.PACKAGE_CLASS + ": " + fqName);
+        }
+    }
+
+    public ResolverScopeData(boolean negative) {
+        if (!negative) {
+            throw new IllegalStateException();
+        }
+        this.psiClass = null;
+        this.psiPackage = null;
+        this.fqName = null;
+        this.staticMembers = false;
+        this.kotlin = false;
+        this.classOrNamespaceDescriptor = null;
+    }
+
+    @NotNull
+    public PsiElement getPsiPackageOrPsiClass() {
+        if (psiPackage != null) {
+            return psiPackage;
+        }
+        else {
+            assert psiClass != null;
+            return psiClass;
+        }
+    }
+
+    private Map<Name, NamedMembers> namedMembersMap;
+
+    public Map<Name, NamedMembers> getNamedMembersMap() {
+        return namedMembersMap;
+    }
+
+    public void setNamedMembersMap(Map<Name, NamedMembers> namedMembersMap) {
+        this.namedMembersMap = namedMembersMap;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverSyntheticClassObjectClassData.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2012 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.data;
+
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+/**
+* @author Pavel Talanov
+*/
+public class ResolverSyntheticClassObjectClassData extends ResolverClassData {
+
+    public ResolverSyntheticClassObjectClassData(
+            @Nullable PsiClass psiClass,
+            @Nullable FqName fqName,
+            @NotNull ClassDescriptorFromJvmBytecode descriptor
+    ) {
+        super(psiClass, null, fqName, true, descriptor);
+    }
+}

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

@@ -23,8 +23,9 @@ import org.jetbrains.jet.lang.descriptors.ClassKind;
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.MutableClassDescriptorLite;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverBinaryClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
 import org.jetbrains.jet.lang.resolve.lazy.LazyClassDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
@@ -39,7 +40,7 @@ public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite {
     @NotNull
     private final JavaDescriptorResolver javaDescriptorResolver;
     @NotNull
-    private final JavaDescriptorResolveData.ResolverClassData resolverBinaryClassData;
+    private final ResolverClassData resolverBinaryClassData;
 
 
     // lazy
@@ -51,11 +52,11 @@ public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite {
             @NotNull JavaDescriptorResolver javaDescriptorResolver) {
         super(containingDeclaration, kind);
         this.javaDescriptorResolver = javaDescriptorResolver;
-        this.resolverBinaryClassData = new JavaDescriptorResolveData.ResolverBinaryClassData(psiClass, fqName, this);
+        this.resolverBinaryClassData = new ResolverBinaryClassData(psiClass, fqName, this);
     }
 
     @NotNull
-    public JavaDescriptorResolveData.ResolverClassData getResolverBinaryClassData() {
+    public ResolverClassData getResolverBinaryClassData() {
         return resolverBinaryClassData;
     }
 

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

@@ -28,6 +28,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverBinaryClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverSyntheticClassObjectClassData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassMembersScope;
@@ -60,8 +63,8 @@ public final class ClassResolver {
     private final JavaDescriptorResolver javaDescriptorResolver;
 
     // NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects)
-    private final Map<FqNameBase, JavaDescriptorResolveData.ResolverClassData> classDescriptorCache =
+    private final Map<FqNameBase, ResolverClassData> classDescriptorCache =
-            new THashMap<FqNameBase, JavaDescriptorResolveData.ResolverClassData>(new TObjectHashingStrategy<FqNameBase>() {
+            new THashMap<FqNameBase, ResolverClassData>(new TObjectHashingStrategy<FqNameBase>() {
                 @Override
                 public int computeHashCode(FqNameBase o) {
                     if (o instanceof FqName) {
@@ -125,14 +128,14 @@ public final class ClassResolver {
         }
 
         // Not let's take a descriptor of a Java class
-        JavaDescriptorResolveData.ResolverClassData classData = classDescriptorCache.get(qualifiedName);
+        ResolverClassData classData = classDescriptorCache.get(qualifiedName);
         if (classData == null) {
             PsiClass psiClass =
                     javaDescriptorResolver.getPsiClassFinder().findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
             if (psiClass == null) {
-                JavaDescriptorResolveData.ResolverClassData oldValue =
+                ResolverClassData oldValue =
                         classDescriptorCache
-                                .put(qualifiedName, JavaDescriptorResolveData.ResolverBinaryClassData.NEGATIVE);
+                                .put(qualifiedName, ResolverBinaryClassData.NEGATIVE);
                 if (oldValue != null) {
                     throw new IllegalStateException("rewrite at " + qualifiedName);
                 }
@@ -144,7 +147,7 @@ public final class ClassResolver {
     }
 
     @NotNull
-    private JavaDescriptorResolveData.ResolverClassData createJavaClassDescriptor(
+    private ResolverClassData createJavaClassDescriptor(
             @NotNull final PsiClass psiClass,
             List<Runnable> taskList
     ) {
@@ -164,7 +167,7 @@ public final class ClassResolver {
         ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass);
 
         // class may be resolved during resolution of parent
-        JavaDescriptorResolveData.ResolverClassData classData = classDescriptorCache.get(fqName);
+        ResolverClassData classData = classDescriptorCache.get(fqName);
         if (classData != null) {
             return classData;
         }
@@ -251,7 +254,7 @@ public final class ClassResolver {
         final String qualifiedName = classObjectPsiClass.getQualifiedName();
         assert qualifiedName != null;
         FqName fqName = new FqName(qualifiedName);
-        JavaDescriptorResolveData.ResolverClassData classData = new ClassDescriptorFromJvmBytecode(
+        ResolverClassData classData = new ClassDescriptorFromJvmBytecode(
                 containing, ClassKind.CLASS_OBJECT, classObjectPsiClass, fqName, javaDescriptorResolver)
                 .getResolverBinaryClassData();
 
@@ -265,7 +268,7 @@ public final class ClassResolver {
     private void setUpClassObjectDescriptor(
             @NotNull ClassDescriptor containing,
             @NotNull FqNameBase fqName,
-            @NotNull JavaDescriptorResolveData.ResolverClassData data,
+            @NotNull ResolverClassData data,
             @NotNull Name classObjectName
     ) {
         ClassDescriptorFromJvmBytecode classDescriptor = data.getClassDescriptor();
@@ -308,8 +311,8 @@ public final class ClassResolver {
         ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode(
                 containing, ClassKind.CLASS_OBJECT, psiClass, null, javaDescriptorResolver);
 
-        JavaDescriptorResolveData.ResolverSyntheticClassObjectClassData
+        ResolverSyntheticClassObjectClassData
-                data = new JavaDescriptorResolveData.ResolverSyntheticClassObjectClassData(psiClass, null, classObjectDescriptor);
+                data = new ResolverSyntheticClassObjectClassData(psiClass, null, classObjectDescriptor);
         setUpClassObjectDescriptor(containing, fqName, data, getClassObjectName(containing.getName().getName()));
 
         return classObjectDescriptor;
@@ -317,7 +320,7 @@ public final class ClassResolver {
 
     public Collection<JetType> getSupertypes(
             PsiClassWrapper psiClass,
-            JavaDescriptorResolveData.ResolverClassData classData,
+            ResolverClassData classData,
             List<TypeParameterDescriptor> typeParameters
     ) {
         ClassDescriptor classDescriptor = classData.getClassDescriptor();

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

@@ -24,7 +24,11 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver;
+import org.jetbrains.jet.lang.resolve.java.TypeVariableResolvers;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
@@ -43,7 +47,7 @@ public final class ConstructorResolver {
     }
 
     @NotNull
-    public Collection<ConstructorDescriptor> resolveConstructors(@NotNull JavaDescriptorResolveData.ResolverClassData classData) {
+    public Collection<ConstructorDescriptor> resolveConstructors(@NotNull ResolverClassData classData) {
         Collection<ConstructorDescriptor> constructors = Lists.newArrayList();
 
         PsiClass psiClass = classData.getPsiClass();
@@ -144,7 +148,7 @@ public final class ConstructorResolver {
     @Nullable
     private ConstructorDescriptor resolveConstructor(
             PsiClass psiClass,
-            JavaDescriptorResolveData.ResolverClassData classData,
+            ResolverClassData classData,
             boolean aStatic,
             PsiMethod psiConstructor
     ) {

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

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
 import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
@@ -50,7 +51,7 @@ public final class FunctionResolver {
     @Nullable
     private SimpleFunctionDescriptor resolveMethodToFunctionDescriptor(
             @NotNull final PsiClass psiClass, final PsiMethodWrapper method,
-            @NotNull JavaDescriptorResolveData.ResolverScopeData scopeData
+            @NotNull ResolverScopeData scopeData
     ) {
 
         DescriptorResolverUtils.getResolverScopeData(scopeData);
@@ -142,7 +143,7 @@ public final class FunctionResolver {
 
     private void resolveNamedGroupFunctions(
             @NotNull ClassOrNamespaceDescriptor owner, PsiClass psiClass,
-            NamedMembers namedMembers, Name methodName, JavaDescriptorResolveData.ResolverScopeData scopeData
+            NamedMembers namedMembers, Name methodName, ResolverScopeData scopeData
     ) {
         if (namedMembers.getFunctionDescriptors() != null) {
             return;
@@ -194,7 +195,7 @@ public final class FunctionResolver {
         namedMembers.setFunctionDescriptors(functions);
     }
 
-    public Set<FunctionDescriptor> resolveFunctionGroup(Name methodName, JavaDescriptorResolveData.ResolverScopeData scopeData) {
+    public Set<FunctionDescriptor> resolveFunctionGroup(Name methodName, ResolverScopeData scopeData) {
         DescriptorResolverUtils.getResolverScopeData(scopeData);
 
         Map<Name, NamedMembers> namedMembersMap = scopeData.getNamedMembersMap();
@@ -239,7 +240,7 @@ public final class FunctionResolver {
     }
 
     public static Set<SimpleFunctionDescriptor> getFunctionsFromSupertypes(
-            JavaDescriptorResolveData.ResolverScopeData scopeData,
+            ResolverScopeData scopeData,
             Name methodName
     ) {
         Set<SimpleFunctionDescriptor> r = Sets.newLinkedHashSet();
@@ -251,7 +252,7 @@ public final class FunctionResolver {
         return r;
     }
 
-    public List<FunctionDescriptor> resolveMethods(@NotNull JavaDescriptorResolveData.ResolverScopeData scopeData) {
+    public List<FunctionDescriptor> resolveMethods(@NotNull ResolverScopeData scopeData) {
 
         DescriptorResolverUtils.getResolverScopeData(scopeData);
 

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

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverNamespaceData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -39,7 +40,7 @@ public final class NamespaceResolver {
 
     public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptor(JavaDescriptorResolver.JAVA_ROOT);
     private final JavaDescriptorResolver javaDescriptorResolver;
-    private final Map<FqName, JavaDescriptorResolveData.ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
+    private final Map<FqName, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
 
     public NamespaceResolver(JavaDescriptorResolver javaDescriptorResolver) {
         this.javaDescriptorResolver = javaDescriptorResolver;
@@ -66,7 +67,7 @@ public final class NamespaceResolver {
             }
         }
 
-        JavaDescriptorResolveData.ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(qualifiedName);
+        ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(qualifiedName);
         if (namespaceData != null) {
             return namespaceData.getNamespaceDescriptor();
         }
@@ -82,7 +83,7 @@ public final class NamespaceResolver {
                 qualifiedName
         );
 
-        JavaDescriptorResolveData.ResolverNamespaceData scopeData = createNamespaceResolverScopeData(qualifiedName, ns);
+        ResolverNamespaceData scopeData = createNamespaceResolverScopeData(qualifiedName, ns);
         if (scopeData == null) {
             return null;
         }
@@ -108,7 +109,7 @@ public final class NamespaceResolver {
     }
 
     @Nullable
-    private JavaDescriptorResolveData.ResolverNamespaceData createNamespaceResolverScopeData(
+    private ResolverNamespaceData createNamespaceResolverScopeData(
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor ns
     ) {
@@ -130,20 +131,20 @@ public final class NamespaceResolver {
                 break lookingForPsi;
             }
 
-            JavaDescriptorResolveData.ResolverNamespaceData oldValue =
+            ResolverNamespaceData oldValue =
-                    namespaceDescriptorCacheByFqn.put(fqName, JavaDescriptorResolveData.ResolverNamespaceData.NEGATIVE);
+                    namespaceDescriptorCacheByFqn.put(fqName, ResolverNamespaceData.NEGATIVE);
             if (oldValue != null) {
                 throw new IllegalStateException("rewrite at " + fqName);
             }
             return null;
         }
 
-        JavaDescriptorResolveData.ResolverNamespaceData namespaceData =
+        ResolverNamespaceData namespaceData =
-                new JavaDescriptorResolveData.ResolverNamespaceData(psiClass, psiPackage, fqName, ns);
+                new ResolverNamespaceData(psiClass, psiPackage, fqName, ns);
 
         namespaceData.setMemberScope(new JavaPackageScope(fqName, javaDescriptorResolver.getSemanticServices(), namespaceData));
 
-        JavaDescriptorResolveData.ResolverNamespaceData oldValue =
+        ResolverNamespaceData oldValue =
                 namespaceDescriptorCacheByFqn.put(fqName, namespaceData);
         if (oldValue != null) {
             throw new IllegalStateException("rewrite at " + fqName);
@@ -154,14 +155,14 @@ public final class NamespaceResolver {
 
     @Nullable
     public JavaPackageScope getJavaPackageScope(@NotNull FqName fqName, @NotNull NamespaceDescriptor ns) {
-        JavaDescriptorResolveData.ResolverNamespaceData resolverNamespaceData = namespaceDescriptorCacheByFqn.get(fqName);
+        ResolverNamespaceData resolverNamespaceData = namespaceDescriptorCacheByFqn.get(fqName);
         if (resolverNamespaceData == null) {
             resolverNamespaceData = createNamespaceResolverScopeData(fqName, ns);
         }
         if (resolverNamespaceData == null) {
             return null;
         }
-        if (resolverNamespaceData == JavaDescriptorResolveData.ResolverNamespaceData.NEGATIVE) {
+        if (resolverNamespaceData == ResolverNamespaceData.NEGATIVE) {
             throw new IllegalStateException(
                     "This means that we are trying to create a Java package, but have a package with the same FQN defined in Kotlin: " +
                     fqName);

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

@@ -27,7 +27,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData;
 import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
 import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java

@@ -25,8 +25,8 @@ import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassOrPackageScope.java

@@ -24,7 +24,7 @@ import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java

@@ -21,8 +21,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;