Compare constructed descriptors in diagnostics tests

2014-09-16 15:23:29 +04:00
parent 2a9005b466
commit de61456725
9 changed files with 260 additions and 105 deletions
@@ -16,9 +16,11 @@

 package org.jetbrains.jet.checkers;

+import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Sets;
+import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import kotlin.Function1;
@@ -26,6 +28,10 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.*;
 import org.jetbrains.jet.lang.psi.Call;
@@ -36,15 +42,20 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.test.util.DescriptorValidator;
+import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;

 import java.io.File;
 import java.util.*;

 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.test.util.RecursiveDescriptorComparator.RECURSIVE;

 public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
-
    @Override
    protected void analyzeAndCheck(File testDataFile, List<TestFile> testFiles) {
        Map<TestModule, List<TestFile>> groupedByModule = KotlinPackage.groupByTo(
@@ -80,6 +91,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {

            if (module == null) {
                module = support.newModule();
+                modules.put(entry.getKey(), module);
            }
            else {
                module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
@@ -97,6 +109,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                    null,
                    null
            );
+
            checkAllResolvedCallsAreCompleted(jetFiles, moduleTrace.getBindingContext());
        }

@@ -112,9 +125,83 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
        assertTrue("Diagnostics mismatch. See the output above", ok);

        checkAllResolvedCallsAreCompleted(allJetFiles, supportTrace.getBindingContext());
+
+        File expectedFile = new File(FileUtil.getNameWithoutExtension(testDataFile.getAbsolutePath()) + ".txt");
+        validateAndCompareDescriptorWithFile(expectedFile, testFiles, support, modules);
    }

-    private Map<TestModule, ModuleDescriptorImpl> createModules(Map<TestModule, List<TestFile>> groupedByModule) {
+    private void validateAndCompareDescriptorWithFile(
+            File expectedFile,
+            List<TestFile> testFiles,
+            CliLightClassGenerationSupport support,
+            Map<TestModule, ModuleDescriptorImpl> modules
+    ) {
+        ModuleDescriptorImpl lightClassModule = support.getLightClassModule();
+        if (lightClassModule == null) {
+            ModuleDescriptorImpl cliModule = support.newModule();
+            cliModule.initialize(new PackageFragmentProvider() {
+                @NotNull
+                @Override
+                public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
+                    return Collections.emptyList();
+                }
+
+                @NotNull
+                @Override
+                public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
+                    return Collections.emptyList();
+                }
+            });
+        }
+
+        RecursiveDescriptorComparator comparator = new RecursiveDescriptorComparator(createdAffectedPackagesConfiguration(testFiles));
+
+        boolean isMultiModuleTest = modules.size() != 1;
+        StringBuilder rootPackageText = new StringBuilder();
+
+        for (TestModule module : KotlinPackage.sort(modules.keySet())) {
+            ModuleDescriptorImpl moduleDescriptor = modules.get(module);
+            if (isMultiModuleTest) {
+                rootPackageText.append(String.format("// -- Module: %s --\n", moduleDescriptor.getName()));
+            }
+
+            DeclarationDescriptor aPackage = moduleDescriptor.getPackage(FqName.ROOT);
+            assertNotNull(aPackage);
+
+            String actualSerialized = comparator.serializeRecursively(aPackage);
+            rootPackageText.append(actualSerialized);
+
+            if (isMultiModuleTest) {
+                rootPackageText.append("\n\n");
+            }
+        }
+
+        JetTestUtils.assertEqualsToFile(expectedFile, rootPackageText.toString());
+    }
+
+    public static RecursiveDescriptorComparator.Configuration createdAffectedPackagesConfiguration(List<TestFile> testFiles) {
+        final Set<Name> packagesNames = LazyResolveTestUtil.getTopLevelPackagesFromFileList(getJetFiles(testFiles));
+
+        Predicate<DeclarationDescriptor> stepIntoFilter = new Predicate<DeclarationDescriptor>() {
+            @Override
+            public boolean apply(DeclarationDescriptor descriptor) {
+                if (descriptor instanceof PackageViewDescriptor) {
+                    FqName fqName = ((PackageViewDescriptor) descriptor).getFqName();
+
+                    if (fqName.isRoot()) return true;
+
+                    Name firstName = fqName.pathSegments().get(0);
+                    return packagesNames.contains(firstName);
+                }
+
+                return true;
+            }
+        };
+
+        return RECURSIVE.filterRecursion(stepIntoFilter).withValidationStrategy(DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES);
+    }
+
+    public static Map<TestModule, ModuleDescriptorImpl> createModules(Map<TestModule, List<TestFile>> groupedByModule) {
        Map<TestModule, ModuleDescriptorImpl> modules = new HashMap<TestModule, ModuleDescriptorImpl>();

        for (TestModule testModule : groupedByModule.keySet()) {
@@ -248,7 +248,7 @@ public abstract class BaseDiagnosticsTest extends JetLiteFixture {
                });
    }

-    protected static class TestModule {
+    protected static class TestModule implements Comparable<TestModule> {
        private final String name;
        private final List<TestModule> dependencies = new ArrayList<TestModule>();

@@ -265,6 +265,11 @@ public abstract class BaseDiagnosticsTest extends JetLiteFixture {
        public List<TestModule> getDependencies() {
            return dependencies;
        }
+
+        @Override
+        public int compareTo(@NotNull TestModule module) {
+            return name.compareTo(module.getName());
+        }
    }

    protected class TestFile {
@@ -20,6 +20,7 @@ import com.google.common.base.Predicate;
 import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.checkers.BaseDiagnosticsTest;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -55,13 +56,14 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends BaseDiagnostics
        final Set<Name> names = LazyResolveTestUtil.getTopLevelPackagesFromFileList(jetFiles);
        validateAndCompareDescriptors(
                expected, actual,
-                RECURSIVE.filterRecursion(new Predicate<FqName>() {
+                RECURSIVE.filterRecursion(new Predicate<DeclarationDescriptor>() {
                    @Override
-                    public boolean apply(FqName fqName) {
-                        if (fqName.isRoot()) return true;
-                        if (fqName.parent().isRoot()) {
-                            return names.contains(fqName.shortName());
+                    public boolean apply(DeclarationDescriptor descriptor) {
+                        if (descriptor instanceof PackageViewDescriptor) {
+                            FqName fqName = ((PackageViewDescriptor) descriptor).getFqName();
+                            return fqName.isRoot() || !fqName.parent().isRoot() || names.contains(fqName.shortName());
                        }
+
                        return true;
                    }
                }),
@@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -78,10 +79,13 @@ public abstract class AbstractLazyResolveRecursiveComparingTest extends KotlinTe

        RecursiveDescriptorComparator.validateAndCompareDescriptors(
                expected, actual, RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT.filterRecursion(
-                new Predicate<FqName>() {
+                new Predicate<DeclarationDescriptor>() {
                    @Override
-                    public boolean apply(FqName fqName) {
-                        return !KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName);
+                    public boolean apply(DeclarationDescriptor descriptor) {
+                        if (descriptor instanceof PackageViewDescriptor) {
+                            return !KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(((PackageViewDescriptor) descriptor).getFqName());
+                        }
+                        return true;
                    }
                })
                .checkPrimaryConstructors(checkPrimaryConstructors)
@@ -16,6 +16,8 @@

 package org.jetbrains.jet.test.util;

+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -54,18 +56,29 @@ public class DescriptorValidator {
    }

    public static class ValidationVisitor implements DeclarationDescriptorVisitor<Boolean, DiagnosticCollector> {
-        public static final ValidationVisitor FORBID_ERROR_TYPES = new ValidationVisitor(false);
-        public static final ValidationVisitor ALLOW_ERROR_TYPES = new ValidationVisitor(true);
+        public static final ValidationVisitor FORBID_ERROR_TYPES = new ValidationVisitor(
+                false, Predicates.<DeclarationDescriptor>alwaysTrue());
+        public static final ValidationVisitor ALLOW_ERROR_TYPES = new ValidationVisitor(
+                true, Predicates.<DeclarationDescriptor>alwaysTrue());

        private final boolean allowErrorTypes;
+        private final Predicate<DeclarationDescriptor> recursiveFilter;

-        private ValidationVisitor(boolean allowErrorTypes) {
+        private ValidationVisitor(boolean allowErrorTypes, @NotNull Predicate<DeclarationDescriptor> recursiveFilter) {
            this.allowErrorTypes = allowErrorTypes;
+            this.recursiveFilter = recursiveFilter;
        }

-        private static void validateScope(@NotNull JetScope scope, @NotNull DiagnosticCollector collector) {
+        @NotNull
+        public ValidationVisitor withStepIntoFilter(@NotNull Predicate<DeclarationDescriptor> filter) {
+            return new ValidationVisitor(allowErrorTypes, filter);
+        }
+
+        private void validateScope(@NotNull JetScope scope, @NotNull DiagnosticCollector collector) {
            for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
-                descriptor.accept(new ScopeValidatorVisitor(collector), scope);
+                if (recursiveFilter.apply(descriptor)) {
+                    descriptor.accept(new ScopeValidatorVisitor(collector), scope);
+                }
            }
        }

@@ -173,9 +186,9 @@ public class DescriptorValidator {
        }

        @Override
-        public Boolean visitPackageViewDescriptor(
-                PackageViewDescriptor descriptor, DiagnosticCollector collector
-        ) {
+        public Boolean visitPackageViewDescriptor(PackageViewDescriptor descriptor, DiagnosticCollector collector) {
+            if (!recursiveFilter.apply(descriptor)) return false;
+
            validateScope(descriptor.getMemberScope(), collector);
            return true;
        }
@@ -259,9 +272,9 @@ public class DescriptorValidator {
            visitFunctionDescriptor(constructorDescriptor, collector);

            assertEqualTypes(constructorDescriptor, collector,
-                         "return type",
-                         constructorDescriptor.getContainingDeclaration().getDefaultType(),
-                         constructorDescriptor.getReturnType());
+                             "return type",
+                             constructorDescriptor.getContainingDeclaration().getDefaultType(),
+                             constructorDescriptor.getReturnType());

            return true;
        }
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.MemberComparator;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -51,31 +52,36 @@ public class RecursiveDescriptorComparator {
            .setVerbose(true).build();

    public static final Configuration DONT_INCLUDE_METHODS_OF_OBJECT = new Configuration(false, false, false, 
-                                                                                         Predicates.<FqName>alwaysTrue(),
+                                                                                         Predicates.<DeclarationDescriptor>alwaysTrue(),
                                                                                         FORBID_ERROR_TYPES, DEFAULT_RENDERER);
    public static final Configuration RECURSIVE = new Configuration(false, false, true, 
-                                                                    Predicates.<FqName>alwaysTrue(),
+                                                                    Predicates.<DeclarationDescriptor>alwaysTrue(),
                                                                    FORBID_ERROR_TYPES, DEFAULT_RENDERER);

    public static final Configuration RECURSIVE_ALL = new Configuration(true, true, true, 
-                                                                        Predicates.<FqName>alwaysTrue(),
+                                                                        Predicates.<DeclarationDescriptor>alwaysTrue(),
                                                                        FORBID_ERROR_TYPES, DEFAULT_RENDERER);

    private static final ImmutableSet<String> KOTLIN_ANY_METHOD_NAMES = ImmutableSet.of("equals", "hashCode", "toString");

    private final Configuration conf;

-    private RecursiveDescriptorComparator(@NotNull Configuration conf) {
+    public RecursiveDescriptorComparator(@NotNull Configuration conf) {
        this.conf = conf;
    }

-    private String serializeRecursively(@NotNull DeclarationDescriptor declarationDescriptor) {
+    public String serializeRecursively(@NotNull DeclarationDescriptor declarationDescriptor) {
        StringBuilder result = new StringBuilder();
-        appendDeclarationRecursively(declarationDescriptor, new Printer(result, 1), true);
+        appendDeclarationRecursively(declarationDescriptor, DescriptorUtils.getContainingModule(declarationDescriptor), new Printer(result, 1), true);
        return result.toString();
    }

-    private void appendDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull Printer printer, boolean topLevel) {
+    private void appendDeclarationRecursively(
+            @NotNull DeclarationDescriptor descriptor,
+            @NotNull ModuleDescriptor module,
+            @NotNull Printer printer,
+            boolean topLevel
+    ) {
        if ((descriptor instanceof ClassOrPackageFragmentDescriptor || descriptor instanceof PackageViewDescriptor) && !topLevel) {
            printer.println();
        }
@@ -94,20 +100,23 @@ public class RecursiveDescriptorComparator {

            if (descriptor instanceof ClassDescriptor) {
                ClassDescriptor klass = (ClassDescriptor) descriptor;
-                appendSubDescriptors(klass.getDefaultType().getMemberScope(), getConstructorsAndClassObject(klass), printer);
+                appendSubDescriptors(descriptor, module,
+                                     klass.getDefaultType().getMemberScope(), getConstructorsAndClassObject(klass), printer);
                JetScope staticScope = klass.getStaticScope();
                if (!staticScope.getAllDescriptors().isEmpty()) {
                    printer.println();
                    printer.println("// Static members");
-                    appendSubDescriptors(staticScope, Collections.<DeclarationDescriptor>emptyList(), printer);
+                    appendSubDescriptors(descriptor, module, staticScope, Collections.<DeclarationDescriptor>emptyList(), printer);
                }
            }
            else if (descriptor instanceof PackageFragmentDescriptor) {
-                appendSubDescriptors(((PackageFragmentDescriptor) descriptor).getMemberScope(),
+                appendSubDescriptors(descriptor, module,
+                                     ((PackageFragmentDescriptor) descriptor).getMemberScope(),
                                     Collections.<DeclarationDescriptor>emptyList(), printer);
            }
            else if (descriptor instanceof PackageViewDescriptor) {
-                appendSubDescriptors(((PackageViewDescriptor) descriptor).getMemberScope(),
+                appendSubDescriptors(descriptor, module,
+                                     ((PackageViewDescriptor) descriptor).getMemberScope(),
                                     Collections.<DeclarationDescriptor>emptyList(), printer);
            }

@@ -145,20 +154,24 @@ public class RecursiveDescriptorComparator {
    }

    private boolean shouldSkip(@NotNull DeclarationDescriptor subDescriptor) {
-        return subDescriptor.getContainingDeclaration() instanceof ClassDescriptor
-                && subDescriptor instanceof FunctionDescriptor
-                && KOTLIN_ANY_METHOD_NAMES.contains(subDescriptor.getName().asString())
-                && !conf.includeMethodsOfKotlinAny
-            ||
-                subDescriptor instanceof PackageViewDescriptor
-                && !conf.recurseIntoPackage.apply(((PackageViewDescriptor) subDescriptor).getFqName());
+        boolean isFunctionFromAny = subDescriptor.getContainingDeclaration() instanceof ClassDescriptor
+                                    && subDescriptor instanceof FunctionDescriptor
+                                    && KOTLIN_ANY_METHOD_NAMES.contains(subDescriptor.getName().asString());
+        return (isFunctionFromAny && !conf.includeMethodsOfKotlinAny) || !conf.recursiveFilter.apply(subDescriptor);
    }

    private void appendSubDescriptors(
+            @NotNull DeclarationDescriptor descriptor,
+            @NotNull ModuleDescriptor module,
            @NotNull JetScope memberScope,
            @NotNull Collection<DeclarationDescriptor> extraSubDescriptors,
            @NotNull Printer printer
    ) {
+        if (!module.equals(DescriptorUtils.getContainingModule(descriptor))) {
+            printer.println(String.format("// -- Module: %s --", DescriptorUtils.getContainingModule(descriptor).getName()));
+            return;
+        }
+
        List<DeclarationDescriptor> subDescriptors = Lists.newArrayList();

        subDescriptors.addAll(memberScope.getAllDescriptors());
@@ -168,7 +181,7 @@ public class RecursiveDescriptorComparator {

        for (DeclarationDescriptor subDescriptor : subDescriptors) {
            if (!shouldSkip(subDescriptor)) {
-                appendDeclarationRecursively(subDescriptor, printer, false);
+                appendDeclarationRecursively(subDescriptor, module, printer, false);
            }
        }
    }
@@ -239,7 +252,7 @@ public class RecursiveDescriptorComparator {
        private final boolean checkPrimaryConstructors;
        private final boolean checkPropertyAccessors;
        private final boolean includeMethodsOfKotlinAny;
-        private final Predicate<FqName> recurseIntoPackage;
+        private final Predicate<DeclarationDescriptor> recursiveFilter;
        private final DescriptorRenderer renderer;

        private final DescriptorValidator.ValidationVisitor validationStrategy;
@@ -248,45 +261,45 @@ public class RecursiveDescriptorComparator {
                boolean checkPrimaryConstructors,
                boolean checkPropertyAccessors,
                boolean includeMethodsOfKotlinAny,
-                Predicate<FqName> recurseIntoPackage,
+                Predicate<DeclarationDescriptor> recursiveFilter,
                DescriptorValidator.ValidationVisitor validationStrategy,
                DescriptorRenderer renderer
        ) {
            this.checkPrimaryConstructors = checkPrimaryConstructors;
            this.checkPropertyAccessors = checkPropertyAccessors;
            this.includeMethodsOfKotlinAny = includeMethodsOfKotlinAny;
-            this.recurseIntoPackage = recurseIntoPackage;
-            this.validationStrategy = validationStrategy;
+            this.recursiveFilter = recursiveFilter;
+            this.validationStrategy = validationStrategy.withStepIntoFilter(recursiveFilter);
            this.renderer = renderer;
        }

-        public Configuration filterRecursion(@NotNull Predicate<FqName> recurseIntoPackage) {
-            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recurseIntoPackage,
+        public Configuration filterRecursion(@NotNull Predicate<DeclarationDescriptor> stepIntoFilter) {
+            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, stepIntoFilter,
                                     validationStrategy, renderer);
        }

        public Configuration checkPrimaryConstructors(boolean checkPrimaryConstructors) {
-            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recurseIntoPackage,
+            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recursiveFilter,
                                     validationStrategy, renderer);
        }

        public Configuration checkPropertyAccessors(boolean checkPropertyAccessors) {
-            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recurseIntoPackage,
+            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recursiveFilter,
                                     validationStrategy, renderer);
        }

        public Configuration includeMethodsOfKotlinAny(boolean includeMethodsOfKotlinAny) {
-            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recurseIntoPackage,
+            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recursiveFilter,
                                     validationStrategy, renderer);
        }

        public Configuration withValidationStrategy(@NotNull DescriptorValidator.ValidationVisitor validationStrategy) {
-            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recurseIntoPackage,
+            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recursiveFilter,
                                     validationStrategy, renderer);
        }

        public Configuration withRenderer(@NotNull DescriptorRenderer renderer) {
-            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recurseIntoPackage,
+            return new Configuration(checkPrimaryConstructors, checkPropertyAccessors, includeMethodsOfKotlinAny, recursiveFilter,
                                     validationStrategy, renderer);
        }
    }