Refactor NamedMembers: encapsulate fields

Also some stylistic changes

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

@@ -79,15 +79,11 @@ public final class JavaDescriptorPropertiesResolver {
     ) {
         JavaDescriptorResolver.getResolverScopeData(scopeData);
 
-        if (namedMembers.propertyDescriptors != null) {
+        if (namedMembers.getPropertyDescriptors() != null) {
             return;
         }
 
-        if (namedMembers.propertyAccessors == null) {
-            namedMembers.propertyAccessors = Collections.emptyList();
-        }
-
-        Map<String, GroupingValue> map = collectGroupingValuesFromAccessors(namedMembers.propertyAccessors);
+        Map<String, GroupingValue> map = collectGroupingValuesFromAccessors(namedMembers.getPropertyAccessors());
 
         Set<PropertyDescriptor> propertiesFromCurrent = new HashSet<PropertyDescriptor>(1);
 
@@ -263,7 +259,7 @@ public final class JavaDescriptorPropertiesResolver {
         OverrideResolver.resolveUnknownVisibilities(properties, trace);
         properties.addAll(propertiesFromCurrent);
 
-        namedMembers.propertyDescriptors = Sets.<VariableDescriptor>newHashSet(properties);
+        namedMembers.setPropertyDescriptors(Sets.<VariableDescriptor>newHashSet(properties));
     }
 
     private List<TypeParameterDescriptor> resolvePropertyTypeParameters(

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

@@ -941,7 +941,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         javaDescriptorPropertiesResolver.resolveNamedGroupProperties(scopeData.getClassOrNamespaceDescriptor(), scopeData, namedMembers, fieldName,
                 "class or namespace " + qualifiedName);
 
-        return namedMembers.propertyDescriptors;
+        return namedMembers.getPropertyDescriptors();
     }
     
     @NotNull
@@ -960,7 +960,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
             javaDescriptorPropertiesResolver.resolveNamedGroupProperties(
                     scopeData.getClassOrNamespaceDescriptor(), scopeData, namedMembers, propertyName,
                     "class or namespace " + psiClass.getQualifiedName());
-            descriptors.addAll(namedMembers.propertyDescriptors);
+            descriptors.addAll(namedMembers.getPropertyDescriptors());
         }
 
         return descriptors;
@@ -970,14 +970,14 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
             @NotNull ClassOrNamespaceDescriptor owner, PsiClass psiClass,
             NamedMembers namedMembers, Name methodName, ResolverScopeData scopeData
     ) {
-        if (namedMembers.functionDescriptors != null) {
+        if (namedMembers.getFunctionDescriptors() != null) {
             return;
         }
 
         final Set<FunctionDescriptor> functions = new HashSet<FunctionDescriptor>();
 
         Set<SimpleFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
-        for (PsiMethodWrapper method : namedMembers.methods) {
+        for (PsiMethodWrapper method : namedMembers.getMethods()) {
             SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(psiClass, method, scopeData);
             if (function != null) {
                 functionsFromCurrent.add(function);
@@ -1014,7 +1014,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
             }
         }
 
-        namedMembers.functionDescriptors = functions;
+        namedMembers.setFunctionDescriptors(functions);
     }
 
     private static Set<SimpleFunctionDescriptor> getFunctionsFromSupertypes(ResolverScopeData scopeData, Name methodName) {
@@ -1041,11 +1041,11 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         Map<Name, NamedMembers> namedMembersMap = scopeData.getNamedMembersMap();
 
         NamedMembers namedMembers = namedMembersMap.get(methodName);
-        if (namedMembers != null && namedMembers.methods != null) {
+        if (namedMembers != null) {
 
             resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), scopeData.getPsiClass(), namedMembers, methodName, scopeData);
 
-            return namedMembers.functionDescriptors;
+            return namedMembers.getFunctionDescriptors();
         }
         else {
             return Collections.emptySet();
@@ -1408,7 +1408,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
             NamedMembers namedMembers = entry.getValue();
             resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), scopeData.getPsiClass(),
                                        namedMembers, methodName, scopeData);
-            functions.addAll(namedMembers.functionDescriptors);
+            functions.addAll(namedMembers.getFunctionDescriptors());
         }
 
         return functions;

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

@@ -16,36 +16,65 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.google.common.collect.Lists;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
 /**
 * @author Stepan Koltsov
 */
-class NamedMembers {
-    List<PsiMethodWrapper> methods = new ArrayList<PsiMethodWrapper>(0);
+public class NamedMembers {
 
-    @Nullable
-    List<PropertyAccessorData> propertyAccessors;
+    @NotNull
+    private final List<PsiMethodWrapper> methods = Lists.newArrayList();
+
+    @NotNull
+    private final List<PropertyAccessorData> propertyAccessors = Lists.newArrayList();
+
+    private Set<VariableDescriptor> propertyDescriptors;
 
-    Set<VariableDescriptor> propertyDescriptors;
     /** Including from supertypes */
-    Set<FunctionDescriptor> functionDescriptors;
+    private Set<FunctionDescriptor> functionDescriptors;
 
-    void addMethod(PsiMethodWrapper method) {
+    void addMethod(@NotNull PsiMethodWrapper method) {
         methods.add(method);
     }
-    
-    void addPropertyAccessor(PropertyAccessorData propertyAccessorData) {
-        if (propertyAccessors == null) {
-            propertyAccessors = new ArrayList<PropertyAccessorData>();
-        }
+
+    void addPropertyAccessor(@NotNull PropertyAccessorData propertyAccessorData) {
         propertyAccessors.add(propertyAccessorData);
     }
+
+    @NotNull
+    public List<PsiMethodWrapper> getMethods() {
+        return methods;
+    }
+
+    @NotNull
+    public List<PropertyAccessorData> getPropertyAccessors() {
+        return propertyAccessors;
+    }
+
+    @Nullable
+    public Set<VariableDescriptor> getPropertyDescriptors() {
+        return propertyDescriptors;
+    }
+
+    public void setPropertyDescriptors(@NotNull Set<VariableDescriptor> propertyDescriptors) {
+        this.propertyDescriptors = propertyDescriptors;
+    }
+
+    @Nullable
+    public Set<FunctionDescriptor> getFunctionDescriptors() {
+        return functionDescriptors;
+    }
+
+    public void setFunctionDescriptors(@NotNull Set<FunctionDescriptor> functionDescriptors) {
+        this.functionDescriptors = functionDescriptors;
+    }
 }