JavaDescriptorResolveData.ResolverScopeData fields are private and accessed via getters

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

@@ -45,7 +45,7 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
             @NotNull ResolverScopeData resolverScopeData) {
         super(semanticServices, resolverScopeData);
 
-        if (resolverScopeData.psiClass == null) {
+        if (resolverScopeData.getPsiClass() == null) {
             throw new IllegalArgumentException("must pass PsiClass here");
         }
     }
@@ -79,9 +79,9 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
 
     private ClassifierDescriptor doGetClassifierDescriptor(Name name) {
         // TODO : suboptimal, walk the list only once
-        for (PsiClass innerClass : resolverScopeData.psiClass.getAllInnerClasses()) {
+        for (PsiClass innerClass : resolverScopeData.getPsiClass().getAllInnerClasses()) {
             if (name.getName().equals(innerClass.getName())) {
-                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != resolverScopeData.staticMembers) return null;
+                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != resolverScopeData.isStaticMembers()) return null;
                 ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver()
                         .resolveClass(new FqName(innerClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                 if (classDescriptor != null) {

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

@@ -53,7 +53,7 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
     @NotNull
     @Override
     public DeclarationDescriptor getContainingDeclaration() {
-        return resolverScopeData.classOrNamespaceDescriptor;
+        return resolverScopeData.getClassOrNamespaceDescriptor();
     }
 
     @NotNull
@@ -74,7 +74,7 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
 
-            if (resolverScopeData.psiClass != null) {
+            if (resolverScopeData.getPsiClass() != null) {
 
                 ProgressIndicatorProvider.checkCanceled();
                 allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(resolverScopeData));
@@ -85,21 +85,21 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
                 // TODO: Trying to hack the situation when we produce namespace descriptor for java class and still want to see inner classes
                 if (getContainingDeclaration() instanceof JavaNamespaceDescriptor) {
                     allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(
-                            resolverScopeData.classOrNamespaceDescriptor, resolverScopeData.psiClass, false));
+                            resolverScopeData.getClassOrNamespaceDescriptor(), resolverScopeData.getPsiClass(), false));
                 }
                 else {
                     allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(
-                            resolverScopeData.classOrNamespaceDescriptor, resolverScopeData.psiClass,
+                            resolverScopeData.getClassOrNamespaceDescriptor(), resolverScopeData.getPsiClass(),
-                            resolverScopeData.staticMembers));
+                            resolverScopeData.isStaticMembers()));
                 }
             }
 
-            if (resolverScopeData.psiPackage != null) {
+            if (resolverScopeData.getPsiPackage() != null) {
-                FqName packageFqName = resolverScopeData.fqName;
+                FqName packageFqName = resolverScopeData.getFqName();
                 boolean isKotlinNamespace = packageFqName != null && semanticServices.getKotlinNamespaceDescriptor(packageFqName) != null;
                 final JavaDescriptorResolver descriptorResolver = semanticServices.getDescriptorResolver();
 
-                for (PsiPackage psiSubPackage : resolverScopeData.psiPackage.getSubPackages()) {
+                for (PsiPackage psiSubPackage : resolverScopeData.getPsiPackage().getSubPackages()) {
                     NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(
                             new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                     if (childNs != null) {
@@ -107,7 +107,7 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
                     }
                 }
 
-                for (PsiClass psiClass : resolverScopeData.psiPackage.getClasses()) {
+                for (PsiClass psiClass : resolverScopeData.getPsiPackage().getClasses()) {
                     if (isKotlinNamespace && JvmAbi.PACKAGE_CLASS.equals(psiClass.getName())) {
                         continue;
                     }

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

@@ -327,7 +327,7 @@ public final class JavaDescriptorPropertiesResolver {
     }
 
     private static boolean isPropertyFinal(ResolverScopeData scopeData, GroupingValue members) {
-        if (!scopeData.kotlin) {
+        if (!scopeData.isKotlin()) {
             return true;
         }
 
@@ -376,7 +376,7 @@ public final class JavaDescriptorPropertiesResolver {
             @NotNull ResolverScopeData scopeData,
             boolean isStatic
     ) {
-        final PsiClass psiClass = scopeData.psiClass;
+        final PsiClass psiClass = scopeData.getPsiClass();
         assert psiClass != null;
 
         boolean isEnum = psiClass.isEnum();

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

@@ -35,14 +35,41 @@ import java.util.Map;
 class JavaDescriptorResolveData {
     static abstract class ResolverScopeData {
         @Nullable
-        final PsiClass psiClass;
+        public PsiClass getPsiClass() {
+            return psiClass;
+        }
+
         @Nullable
-        final PsiPackage psiPackage;
+        public PsiPackage getPsiPackage() {
+            return psiPackage;
+        }
+
         @Nullable
-        final FqName fqName;
+        public FqName getFqName() {
-        final boolean staticMembers;
+            return fqName;
-        final boolean kotlin;
+        }
-        final ClassOrNamespaceDescriptor classOrNamespaceDescriptor;
+
+        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) {
             JavaDescriptorResolver.checkPsiClassIsNotJet(psiClass);

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

@@ -283,7 +283,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public Collection<ConstructorDescriptor> resolveConstructors(@NotNull ResolverClassData classData) {
         Collection<ConstructorDescriptor> constructors = Lists.newArrayList();
 
-        PsiClass psiClass = classData.psiClass;
+        PsiClass psiClass = classData.getPsiClass();
 
         ClassDescriptorFromJvmBytecode containingClass = classData.classDescriptor;
         assert psiClass != null;
@@ -609,7 +609,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         }
         
         if (result.isEmpty()) {
-            if (classData.kotlin
+            if (classData.isKotlin()
                     || OBJECT_FQ_NAME.equalsTo(psiClass.getQualifiedName())
                     // TODO: annotations
                     || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
@@ -882,7 +882,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
 
     public Set<VariableDescriptor> resolveFieldGroupByName(@NotNull Name fieldName, @NotNull ResolverScopeData scopeData) {
 
-        final PsiClass psiClass = scopeData.psiClass;
+        final PsiClass psiClass = scopeData.getPsiClass();
         if (psiClass == null) {
             return Collections.emptySet();
         }
@@ -896,7 +896,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
 
         final String qualifiedName = psiClass.getQualifiedName();
         javaDescriptorPropertiesResolver.resolveNamedGroupProperties(
-                scopeData.classOrNamespaceDescriptor, scopeData, namedMembers, fieldName,
+                scopeData.getClassOrNamespaceDescriptor(), scopeData, namedMembers, fieldName,
                 "class or namespace " + qualifiedName);
 
         return namedMembers.propertyDescriptors;
@@ -906,7 +906,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public Set<VariableDescriptor> resolveFieldGroup(@NotNull ResolverScopeData scopeData) {
 
         getResolverScopeData(scopeData);
-        final PsiClass psiClass = scopeData.psiClass;
+        final PsiClass psiClass = scopeData.getPsiClass();
         assert psiClass != null;
 
         Set<VariableDescriptor> descriptors = Sets.newHashSet();
@@ -916,7 +916,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
             Name propertyName = entry.getKey();
 
             javaDescriptorPropertiesResolver.resolveNamedGroupProperties(
-                    scopeData.classOrNamespaceDescriptor, scopeData, namedMembers, propertyName,
+                    scopeData.getClassOrNamespaceDescriptor(), scopeData, namedMembers, propertyName,
                     "class or namespace " + psiClass.getQualifiedName());
             descriptors.addAll(namedMembers.propertyDescriptors);
         }
@@ -1001,7 +1001,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         NamedMembers namedMembers = namedMembersMap.get(methodName);
         if (namedMembers != null && namedMembers.methods != null) {
 
-            resolveNamedGroupFunctions(scopeData.classOrNamespaceDescriptor, scopeData.psiClass, namedMembers, methodName, scopeData);
+            resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), scopeData.getPsiClass(), namedMembers, methodName, scopeData);
 
             return namedMembers.functionDescriptors;
         }
@@ -1055,7 +1055,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
 
         final PsiMethod psiMethod = method.getPsiMethod();
         final PsiClass containingClass = psiMethod.getContainingClass();
-        if (scopeData.kotlin) {
+        if (scopeData.isKotlin()) {
             // TODO: unless maybe class explicitly extends Object
             assert containingClass != null;
             String ownerClassName = containingClass.getQualifiedName();
@@ -1069,7 +1069,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         }
 
         SimpleFunctionDescriptorImpl functionDescriptorImpl = new SimpleFunctionDescriptorImpl(
-                scopeData.classOrNamespaceDescriptor,
+                scopeData.getClassOrNamespaceDescriptor(),
                 resolveAnnotations(psiMethod),
                 Name.identifier(method.getName()),
                 DescriptorKindUtils.flagsToKind(method.getJetMethod().kind())
@@ -1102,7 +1102,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
 
         functionDescriptorImpl.initialize(
                 valueParameterDescriptors.receiverType,
-                DescriptorUtils.getExpectedThisObjectIfNeeded(scopeData.classOrNamespaceDescriptor),
+                DescriptorUtils.getExpectedThisObjectIfNeeded(scopeData.getClassOrNamespaceDescriptor()),
                 methodTypeParameters,
                 valueParameterDescriptors.descriptors,
                 returnType,
@@ -1364,7 +1364,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         for (Map.Entry<Name, NamedMembers> entry : scopeData.getNamedMembersMap().entrySet()) {
             Name methodName = entry.getKey();
             NamedMembers namedMembers = entry.getValue();
-            resolveNamedGroupFunctions(scopeData.classOrNamespaceDescriptor, scopeData.psiClass,
+            resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), scopeData.getPsiClass(),
                                        namedMembers, methodName, scopeData);
             functions.addAll(namedMembers.functionDescriptors);
         }

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

@@ -208,9 +208,9 @@ class JavaDescriptorResolverHelper {
 
     @NotNull
     static Map<Name, NamedMembers> getNamedMembers(@NotNull ResolverScopeData resolverScopeData) {
-        if (resolverScopeData.psiClass != null) {
+        if (resolverScopeData.getPsiClass() != null) {
             @SuppressWarnings("ConstantConditions")
-            Builder builder = new Builder(new PsiClassWrapper(resolverScopeData.psiClass), resolverScopeData.staticMembers, resolverScopeData.kotlin);
+            Builder builder = new Builder(new PsiClassWrapper(resolverScopeData.getPsiClass()), resolverScopeData.isStaticMembers(), resolverScopeData.isKotlin());
             builder.run();
             return builder.namedMembersMap;
         }

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

@@ -39,7 +39,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
         super(semanticServices, resolverNamespaceData);
         this.packageFQN = packageFQN;
 
-        if (!resolverNamespaceData.staticMembers) {
+        if (!resolverNamespaceData.isStaticMembers()) {
             throw new IllegalArgumentException("instance members should be resolved using " + JavaClassMembersScope.class);
         }
     }