do not enforce order of members in JavaPackageScope and JavaClassMemberScope

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

@@ -87,7 +87,7 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {
-            allDescriptors = Sets.newLinkedHashSet();
+            allDescriptors = Sets.newHashSet();
 
             allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));
 

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

@@ -1024,7 +1024,7 @@ public class JavaDescriptorResolver {
 
         ResolverScopeData scopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass));
         
-        Set<VariableDescriptor> descriptors = Sets.newLinkedHashSet();
+        Set<VariableDescriptor> descriptors = Sets.newHashSet();
         Map<String, NamedMembers> membersForProperties = scopeData.namedMembersMap;
         for (Map.Entry<String, NamedMembers> entry : membersForProperties.entrySet()) {
             NamedMembers namedMembers = entry.getValue();
@@ -1284,7 +1284,7 @@ public class JavaDescriptorResolver {
         
         final Set<FunctionDescriptor> functions = new HashSet<FunctionDescriptor>();
 
-        Set<SimpleFunctionDescriptor> functionsFromCurrent = Sets.newLinkedHashSet();
+        Set<SimpleFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
         for (PsiMethodWrapper method : namedMembers.methods) {
             FunctionDescriptorImpl function = resolveMethodToFunctionDescriptor(owner, psiClass,
                     method);

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

@@ -18,11 +18,14 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiField;
+import com.intellij.psi.PsiMember;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiParameter;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.LinkedHashMap;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -37,7 +40,7 @@ class JavaDescriptorResolverHelper {
         private final boolean staticMembers;
         private final boolean kotlin;
         
-        private Map<String, NamedMembers> namedMembersMap = new LinkedHashMap<String, NamedMembers>();
+        private Map<String, NamedMembers> namedMembersMap = new HashMap<String, NamedMembers>();
 
         private Builder(PsiClassWrapper psiClass, boolean staticMembers, boolean kotlin) {
             this.psiClass = psiClass;

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

@@ -99,7 +99,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {
-            allDescriptors = Sets.newLinkedHashSet();
+            allDescriptors = Sets.newHashSet();
 
             if (psiClass != null) {
                 allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));

idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java

@@ -37,8 +37,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author Evgeny Gerashchenko
@@ -85,7 +84,7 @@ class DecompiledDataFactory {
             NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName));
 
             if (nd != null) {
-                for (DeclarationDescriptor member : nd.getMemberScope().getAllDescriptors()) {
+                for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) {
                     if (member instanceof ClassDescriptor || member instanceof NamespaceDescriptor) {
                         continue;
                     }
@@ -114,6 +113,17 @@ class DecompiledDataFactory {
         return new JetDecompiledData(jetFile, myClsElementsToJetElements);
     }
 
+    private List<DeclarationDescriptor> sortDeclarations(Collection<DeclarationDescriptor> input) {
+        ArrayList<DeclarationDescriptor> r = new ArrayList<DeclarationDescriptor>(input);
+        Collections.sort(r, new Comparator<DeclarationDescriptor>() {
+            @Override
+            public int compare(DeclarationDescriptor o1, DeclarationDescriptor o2) {
+                return o1.getName().compareTo(o2.getName());
+            }
+        });
+        return r;
+    }
+
     private void appendDescriptor(DeclarationDescriptor descriptor, String indent) {
         int startOffset = myBuilder.length();
         myBuilder.append(DescriptorRenderer.COMPACT.render(descriptor));
@@ -140,7 +150,7 @@ class DecompiledDataFactory {
                 myBuilder.append(subindent).append("class ");
                 appendDescriptor(classDescriptor.getClassObjectDescriptor(), subindent);
             }
-            for (DeclarationDescriptor member : classDescriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
+            for (DeclarationDescriptor member : sortDeclarations(classDescriptor.getDefaultType().getMemberScope().getAllDescriptors())) {
                 if (member.getContainingDeclaration() == descriptor) {
                     if (firstPassed) {
                         myBuilder.append("\n");

idea/testData/libraries/ClassWithAbstractAndOpenMembers.kt

@@ -6,16 +6,16 @@ package testData.libraries
 [abstract class ClassWithAbstractAndOpenMembers {
     [abstract fun abstractFun() : Unit]
 
-    [open fun openFun() : Unit { /* compiled code */ }]
-
     [abstract val abstractVal : jet.String]
 
+    [abstract var abstractVar : jet.String]
+
+    [open fun openFun() : Unit { /* compiled code */ }]
+
     [open val openVal : jet.String] /* compiled code */
 
     [open val openValWithGetter : jet.String] /* compiled code */
 
-    [abstract var abstractVar : jet.String]
-
     [open var openVar : jet.String] /* compiled code */
 
     [open var openVarWithGetter : jet.String] /* compiled code */

idea/testData/libraries/namespace.kt

@@ -3,8 +3,8 @@
 
 package testData.libraries
 
-[final fun main(val args : jet.Array<jet.String>) : Unit { /* compiled code */ }]
-
 [final val globalVal : #(jet.Int, jet.String)] /* compiled code */
 
 [final val globalValWithGetter : jet.Long] /* compiled code */
+
+[final fun main(val args : jet.Array<jet.String>) : Unit { /* compiled code */ }]