Add validation that deserialized members are sorted accordingly

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java

@@ -47,6 +47,7 @@ import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.storage.ExceptionTracker;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
+import org.jetbrains.jet.test.util.DescriptorValidator;
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
 import org.junit.Assert;
 
@@ -62,6 +63,7 @@ import java.util.regex.Pattern;
 import static org.jetbrains.jet.JetTestUtils.*;
 import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*;
 import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed;
+import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden;
 import static org.jetbrains.jet.test.util.RecursiveDescriptorComparator.*;
 
 /*
@@ -118,12 +120,12 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
             }
         }
 
-        validateAndCompareDescriptors(packageFromSource, packageFromBinary,
-                                      RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT
-                                              .checkPrimaryConstructors(true)
-                                              .checkPropertyAccessors(true),
-                                      txtFile
-        );
+        DescriptorValidator.validate(errorTypesForbidden(), packageFromSource);
+        DescriptorValidator.validate(new DeserializedScopeValidationVisitor(), packageFromBinary);
+        Configuration configuration = RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT
+                .checkPrimaryConstructors(true)
+                .checkPropertyAccessors(true);
+        compareDescriptors(packageFromSource, packageFromBinary, configuration, txtFile);
     }
 
     protected void doTestJavaAgainstKotlin(String expectedFileName) throws Exception {
@@ -198,7 +200,9 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
         assertNotNull(packageView);
 
-        validateAndCompareDescriptorWithFile(packageView, DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile);
+        validateAndCompareDescriptorWithFile(packageView, DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(
+                new DeserializedScopeValidationVisitor()
+        ), expectedFile);
     }
 
     protected void doTestSourceJava(@NotNull String javaFileName) throws Exception {

compiler/tests/org/jetbrains/jet/jvm/compiler/DeserializedScopeValidationVisitor.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2014 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.jvm.compiler
+
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedMemberScope
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import java.util.Collections
+import org.jetbrains.jet.descriptors.serialization.DescriptorSerializer
+import com.intellij.testFramework.UsefulTestCase
+import java.util.ArrayList
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor
+import org.jetbrains.jet.test.util.DescriptorValidator
+import org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor
+
+class DeserializedScopeValidationVisitor : DescriptorValidator.ValidationVisitor() {
+    override fun validateScope(scope: JetScope, collector: DescriptorValidator.DiagnosticCollector) {
+        super.validateScope(scope, collector)
+        validateDeserializedScope(scope)
+    }
+}
+
+private fun validateDeserializedScope(scope: JetScope) {
+    val isPackageViewScope = scope.safeGetContainingDeclaration() is PackageViewDescriptor
+    if (scope is DeserializedMemberScope || isPackageViewScope) {
+        val relevantDescriptors = scope.getAllDescriptors().filter { member ->
+            member is CallableMemberDescriptor && member.getKind().isReal()
+        }
+        checkSorted(relevantDescriptors, scope.getContainingDeclaration())
+    }
+}
+
+//NOTE: see TypeUtils#IntersectionScope#getContainingDeclaration()
+private fun JetScope.safeGetContainingDeclaration(): DeclarationDescriptor? {
+    return try {
+        getContainingDeclaration()
+    }
+    catch (e: UnsupportedOperationException) {
+        null
+    }
+}
+
+private fun checkSorted(descriptors: Collection<DeclarationDescriptor>, declaration: DeclarationDescriptor) {
+    UsefulTestCase.assertOrderedEquals(
+            "Members of $declaration should be sorted by serialization.",
+            descriptors,
+            descriptors.sortBy(DescriptorSerializer.DESCRIPTOR_COMPARATOR)
+    )
+}

compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java

@@ -67,7 +67,7 @@ public class DescriptorValidator {
         private boolean allowErrorTypes = false;
         private Predicate<DeclarationDescriptor> recursiveFilter = Predicates.alwaysTrue();
 
-        private ValidationVisitor() {
+        protected ValidationVisitor() {
         }
 
         @NotNull
@@ -82,7 +82,7 @@ public class DescriptorValidator {
             return this;
         }
 
-        private void validateScope(@NotNull JetScope scope, @NotNull DiagnosticCollector collector) {
+        protected void validateScope(@NotNull JetScope scope, @NotNull DiagnosticCollector collector) {
             for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
                 if (recursiveFilter.apply(descriptor)) {
                     descriptor.accept(new ScopeValidatorVisitor(collector), scope);

compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java

@@ -205,7 +205,7 @@ public class RecursiveDescriptorComparator {
         doCompareDescriptors(null, actual, configuration, txtFile);
     }
 
-    private static void compareDescriptors(
+    public static void compareDescriptors(
             @NotNull DeclarationDescriptor expected,
             @NotNull DeclarationDescriptor actual,
             @NotNull Configuration configuration,

core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java

@@ -31,7 +31,7 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.*;
 public class DescriptorSerializer {
 
     private static final DescriptorRenderer RENDERER = DescriptorRenderer.STARTS_FROM_NAME;
-    private static final Comparator<DeclarationDescriptor> DESCRIPTOR_COMPARATOR = new Comparator<DeclarationDescriptor>() {
+    public static final Comparator<DeclarationDescriptor> DESCRIPTOR_COMPARATOR = new Comparator<DeclarationDescriptor>() {
         @Override
         public int compare(@NotNull DeclarationDescriptor o1, @NotNull DeclarationDescriptor o2) {
             int names = o1.getName().compareTo(o2.getName());