Drop platform parameter in diagnostic tests(partial revert of 2a334fc).

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -113,7 +113,7 @@ public class JetTestUtils {
      *
      * Several files may follow one module
      */
-    public static final Pattern FILE_OR_MODULE_PATTERN = Pattern.compile("(?://\\s*MODULE(?:\\[(\\w+)\\])?:\\s*(\\w+)(\\(\\w+(?:, \\w+)*\\))?\\s*)?" +
+    public static final Pattern FILE_OR_MODULE_PATTERN = Pattern.compile("(?://\\s*MODULE:\\s*(\\w+)(\\(\\w+(?:, \\w+)*\\))?\\s*)?" +
                                                                          "//\\s*FILE:\\s*(.*)$", Pattern.MULTILINE);
     public static final Pattern DIRECTIVE_PATTERN = Pattern.compile("^//\\s*!(\\w+)(:\\s*(.*)$)?", Pattern.MULTILINE);
 
@@ -500,7 +500,7 @@ public class JetTestUtils {
 
     public interface TestFileFactory<M, F> {
         F createFile(@Nullable M module, @NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives);
-        M createModule(@NotNull String name, @Nullable String platform, @NotNull List<String> dependencies);
+        M createModule(@NotNull String name, @NotNull List<String> dependencies);
     }
 
     public static abstract class TestFileFactoryNoModules<F> implements TestFileFactory<Void, F> {
@@ -518,7 +518,7 @@ public class JetTestUtils {
         public abstract F create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives);
 
         @Override
-        public Void createModule(@NotNull String name, @Nullable String platform, @NotNull List<String> dependencies) {
+        public Void createModule(@NotNull String name, @NotNull List<String> dependencies) {
             return null;
         }
     }
@@ -538,14 +538,13 @@ public class JetTestUtils {
             M module = null;
             // Many files
             while (true) {
-                String platform = matcher.group(1);
+                String moduleName = matcher.group(1);
-                String moduleName = matcher.group(2);
+                String moduleDependencies = matcher.group(2);
-                String moduleDependencies = matcher.group(3);
                 if (moduleName != null) {
-                    module = factory.createModule(moduleName, platform, parseDependencies(moduleDependencies));
+                    module = factory.createModule(moduleName, parseDependencies(moduleDependencies));
                 }
 
-                String fileName = matcher.group(4);
+                String fileName = matcher.group(3);
                 int start = processedChars;
 
                 boolean nextFileExists = matcher.find();

compiler/tests/org/jetbrains/jet/asJava/AbstractKotlinLightClassTest.java

@@ -21,7 +21,6 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.impl.compiled.ClsElementImpl;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.checkers.KotlinMultiFileTestWithWithJava;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
@@ -77,7 +76,7 @@ public abstract class AbstractKotlinLightClassTest extends KotlinMultiFileTestWi
     }
 
     @Override
-    protected Void createTestModule(@NotNull String name, @Nullable String platform) {
+    protected Void createTestModule(@NotNull String name) {
         return null;
     }
 

compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java

@@ -39,7 +39,10 @@ import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.Diagnostics;
 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;
@@ -52,9 +55,6 @@ import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.test.util.DescriptorValidator;
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
 import org.jetbrains.jet.utils.UtilsPackage;
-import org.jetbrains.k2js.analyze.TopDownAnalyzerFacadeForJS;
-import org.jetbrains.k2js.config.Config;
-import org.jetbrains.k2js.config.EcmaVersion;
 
 import java.io.File;
 import java.util.*;
@@ -110,7 +110,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                     ),
                     tracker
             );
-            analyzeModuleContents(context, jetFiles, module, moduleTrace, testModule);
+            analyzeModuleContents(context, jetFiles, module, moduleTrace);
 
             checkAllResolvedCallsAreCompleted(jetFiles, moduleTrace.getBindingContext());
         }
@@ -187,43 +187,20 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
             GlobalContext context,
             List<JetFile> jetFiles,
             ModuleDescriptorImpl module,
-            BindingTrace moduleTrace,
+            BindingTrace moduleTrace
-            TestModule testModule
     ) {
-
+        // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
-        String platform = getPlatform(testModule);
+        // albeit with same class names
-        if ("jvm".equals(platform)) {
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-            // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
+                getProject(),
-            // albeit with same class names
+                context,
-            TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
+                jetFiles,
-                    getProject(),
+                moduleTrace,
-                    context,
+                Predicates.<PsiFile>alwaysTrue(),
-                    jetFiles,
+                module,
-                    moduleTrace,
+                null,
-                    Predicates.<PsiFile>alwaysTrue(),
+                null
-                    module,
+        );
-                    null,
-                    null
-            );
-        }
-        else if ("js".equals(platform)) {
-            TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(
-                    jetFiles,
-                    moduleTrace,
-                    module,
-                    Predicates.<PsiFile>alwaysTrue(),
-                    new Config(getProject(), "module", EcmaVersion.v5, false, true) {
-                        @NotNull
-                        @Override
-                        protected List<JetFile> generateLibFiles() {
-                            return Collections.emptyList();
-                        }
-                    }
-            );
-        }
-        else {
-            throw new IllegalStateException("Unknown platform in module " + testModule.getName() + ": " + platform);
-        }
     }
 
     private void validateAndCompareDescriptorWithFile(
@@ -308,24 +285,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
 
     protected ModuleDescriptorImpl createModule(TestModule testModule) {
         String name = "<" + testModule.getName() + ">";
-        String platform = getPlatform(testModule);
+        return TopDownAnalyzerFacadeForJVM.createJavaModule(name);
-        if ("jvm".equals(platform)) {
-            return TopDownAnalyzerFacadeForJVM.createJavaModule(name);
-        }
-        else if ("js".equals(platform)) {
-            return TopDownAnalyzerFacadeForJS.createJsModule(name);
-        }
-
-        throw new IllegalStateException("Unknown platform in module " + testModule.getName() + ": " + platform);
-    }
-
-    @NotNull
-    private static String getPlatform(@Nullable TestModule testModule) {
-        if (testModule == null) return "jvm";
-
-        String platform = testModule.getPlatform();
-        if (platform == null) return "jvm";
-        return platform;
     }
 
     private static void checkAllResolvedCallsAreCompleted(@NotNull List<JetFile> jetFiles, @NotNull BindingContext bindingContext) {

compiler/tests/org/jetbrains/jet/checkers/BaseDiagnosticsTest.java

@@ -79,8 +79,8 @@ public abstract class BaseDiagnosticsTest extends
     public static final boolean CHECK_LAZY_LOG_DEFAULT = "true".equals(System.getProperty("check.lazy.logs", "false"));
 
     @Override
-    protected TestModule createTestModule(@NotNull String name, @Nullable String platform) {
+    protected TestModule createTestModule(@NotNull String name) {
-        return new TestModule(name, platform);
+        return new TestModule(name);
     }
 
     @Override
@@ -208,12 +208,10 @@ public abstract class BaseDiagnosticsTest extends
 
     protected static class TestModule implements Comparable<TestModule> {
         private final String name;
-        private final String platform;
         private final List<TestModule> dependencies = new ArrayList<TestModule>();
 
-        public TestModule(@NotNull String name, @Nullable String platform) {
+        public TestModule(@NotNull String name) {
             this.name = name;
-            this.platform = platform;
         }
 
         @NotNull
@@ -221,11 +219,6 @@ public abstract class BaseDiagnosticsTest extends
             return name;
         }
 
-        @Nullable
-        public String getPlatform() {
-            return platform;
-        }
-
         @NotNull
         public List<TestModule> getDependencies() {
             return dependencies;

compiler/tests/org/jetbrains/jet/checkers/KotlinMultiFileTestWithWithJava.java

@@ -127,8 +127,8 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
                     }
 
                     @Override
-                    public M createModule(@NotNull String name, @Nullable String platform, @NotNull List<String> dependencies) {
+                    public M createModule(@NotNull String name, @NotNull List<String> dependencies) {
-                        M module = createTestModule(name, platform);
+                        M module = createTestModule(name);
                         ModuleAndDependencies oldValue = modules.put(name, new ModuleAndDependencies(module, dependencies));
                         assert oldValue == null : "Module " + name + " declared more than once";
 
@@ -139,7 +139,7 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
         doMultiFileTest(file, modules, testFiles);
     }
 
-    protected abstract M createTestModule(@NotNull String name, @Nullable String platform);
+    protected abstract M createTestModule(@NotNull String name);
 
     protected abstract F createTestFile(M module, String fileName, String text, Map<String, String> directives);