new fixes

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -33,13 +33,13 @@ import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -91,7 +91,8 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
                 ProjectContext(environment.project), listOf(builtInModule),
                 { ModuleContent(files, GlobalSearchScope.EMPTY_SCOPE) },
                 JvmPlatformParameters { throw IllegalStateException() },
-                CompilerEnvironment
+                CompilerEnvironment,
+                packageMappingProviderFactory = { a, b -> JvmPackageMappingProvider(environment) }
         )
 
         val moduleDescriptor = resolver.descriptorForModule(builtInModule)

compiler/testData/asJava/lightClasses/facades/SingleFile.java

@@ -1,4 +1,3 @@
-@kotlin.jvm.internal.KotlinSyntheticClass(abiVersion = 23, kind = kotlin.jvm.internal.KotlinSyntheticClass.Kind.PACKAGE_PART)
 public final class SingleFileKt {
     public static final void foo() { /* compiled code */ }
 }

compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudocodeTest.java

@@ -54,7 +54,7 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
         JetFile jetFile = JetTestUtils.loadJetFile(getProject(), file);
 
         Map<JetElement, Pseudocode> data = new LinkedHashMap<JetElement, Pseudocode>();
-        AnalysisResult analysisResult = JetTestUtils.analyzeFile(jetFile);
+        AnalysisResult analysisResult = JetTestUtils.analyzeFile(jetFile, getEnvironment());
         List<JetDeclaration> declarations = jetFile.getDeclarations();
         BindingContext bindingContext = analysisResult.getBindingContext();
         for (JetDeclaration declaration : declarations) {

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

@@ -48,8 +48,8 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
 import org.jetbrains.kotlin.storage.ExceptionTracker;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.storage.StorageManager;
@@ -248,7 +248,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                 moduleTrace,
                 null,
                 null,
-                PackageMappingProvider.EMPTY
+                new JvmPackageMappingProvider(getEnvironment())
         );
     }
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileEnvironmentTest.java

@@ -52,8 +52,9 @@ public class CompileEnvironmentTest extends TestCase {
                     "-annotations", jdkAnnotations.getAbsolutePath()
             );
             Assert.assertEquals(ExitCode.OK, exitCode);
-            assertEquals(1, out.listFiles().length);
-            assertEquals(2, out.listFiles()[0].listFiles().length);
+            assertEquals(2, out.listFiles().length);
+            assertEquals(1, out.listFiles()[0].listFiles().length);//META-INF
+            assertEquals(2, out.listFiles()[1].listFiles().length);//Smoke package
         }
         finally {
             FileUtil.delete(tempDir);

compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java

@@ -141,7 +141,7 @@ public final class LoadDescriptorUtil {
                 }
             });
             AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
-                    jetCoreEnvironment.getProject(), jetFiles);
+                    jetCoreEnvironment.getProject(), jetFiles, new JvmPackageMappingProvider(jetCoreEnvironment));
             return new JetFilesAndAnalysisResult(jetFiles, result);
         }
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.junit.Assert
@@ -65,7 +66,8 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
                     val moduleName = javaClass.getName().asString().toLowerCase().first().toString()
                     modules.first { it._name == moduleName }
                 },
-                CompilerEnvironment
+                CompilerEnvironment,
+                packageMappingProviderFactory = { a, b -> JvmPackageMappingProvider(environment)}
         )
 
         performChecks(resolverForProject, modules)

compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt

@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.OverrideRenderingPolicy
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.*
 import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.test.*
@@ -82,7 +82,7 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
 
         val classLoader = URLClassLoader(arrayOf(tmpdir.toURI().toURL()), ForTestCompileRuntime.runtimeAndReflectJarClassLoader())
 
-        val actual = createReflectedPackageView(classLoader, "")
+        val actual = createReflectedPackageView(classLoader, JvmResolveUtil.TEST_MODULE_NAME)
 
         val expected = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot(
                 tmpdir, getTestRootDisposable(), jdkKind, ConfigurationKind.ALL, true

compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java

@@ -338,7 +338,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     @NotNull
     protected JetFile getFile(@NotNull String content) {
         JetFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject());
-        AnalysisResult analysisResult = analyzeFile(ktFile);
+        AnalysisResult analysisResult = JetTestUtils.analyzeFile(ktFile, getEnvironment());
         context = analysisResult.getBindingContext();
 
         return ktFile;
@@ -356,11 +356,6 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
         return getPackage(getFile(content));
     }
 
-    @NotNull
-    protected AnalysisResult analyzeFile(@NotNull JetFile ktFile) {
-        return JetTestUtils.analyzeFile(ktFile);
-    }
-
     protected static String getContent(@NotNull String annotationText) throws IOException {
         File file = new File(PATH);
         return JetTestUtils.doLoadFile(file).replaceAll("ANNOTATION", annotationText);

compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt

@@ -16,16 +16,9 @@
 
 package org.jetbrains.kotlin.resolve.annotation
 
-import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-
 class AnnotationDescriptorResolveWithoutAnalyzeBodyTest : AnnotationDescriptorResolveTest() {
 
     override fun doTest(content: String, expectedAnnotation: String) {
         checkAnnotationOnAllExceptLocalDeclarations(content, expectedAnnotation)
     }
-
-    override fun analyzeFile(ktFile: JetFile): AnalysisResult =
-            JvmResolveUtil.analyzeFilesWithJavaIntegration(ktFile.getProject(), setOf(ktFile), environment);
 }

compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt

@@ -51,7 +51,7 @@ public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
         val text = JetTestUtils.doLoadFile(File(filePath))!!
 
         val jetFile = JetPsiFactory(getProject()).createFile(text.replace("<caret>", ""))
-        val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(jetFile).bindingContext
+        val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(jetFile, environment).bindingContext
 
         val (element, cachedCall) = buildCachedCall(bindingContext, jetFile, text)
 

compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java

@@ -32,6 +32,8 @@ import java.util.Collection;
 import java.util.Collections;
 
 public class JvmResolveUtil {
+
+    public static String TEST_MODULE_NAME = "java-integration-test";
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file) {
         return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackageMappingProvider.EMPTY);
@@ -48,6 +50,11 @@ public class JvmResolveUtil {
         return analysisResult;
     }
 
+    @NotNull
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull KotlinCoreEnvironment environment) {
+        return analyzeOneFileWithJavaIntegration(file, new JvmPackageMappingProvider(environment));
+    }
+
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackageMappingProvider provider) {
         return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), provider);
@@ -98,7 +105,8 @@ public class JvmResolveUtil {
             @NotNull Collection<JetFile> files,
             @NotNull PackageMappingProvider packageMappingProvider
     ) {
-        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, "java-integration-test");
+
+        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, TEST_MODULE_NAME);
 
         BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
 

compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java

@@ -66,6 +66,7 @@ import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
@@ -286,8 +287,8 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static AnalysisResult analyzeFile(@NotNull JetFile file) {
-        return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file);
+    public static AnalysisResult analyzeFile(@NotNull JetFile file, @NotNull KotlinCoreEnvironment environment) {
+        return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file, environment);
     }
 
     @NotNull

compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java

@@ -44,7 +44,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
         File txtFile = new File("compiler/testData/recursiveProcessor/declarations.txt");
         String text = FileUtil.loadFile(ktFile, true);
         JetFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject());
-        AnalysisResult result = JetTestUtils.analyzeFile(jetFile);
+        AnalysisResult result = JetTestUtils.analyzeFile(jetFile, getEnvironment());
         PackageViewDescriptor testPackage = result.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test")));
 
         List<String> descriptors = recursivelyCollectDescriptors(testPackage);

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedNewPackageMemberScope.kt

@@ -58,5 +58,4 @@ public open class DeserializedNewPackageMemberScope(
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
             = membersList.flatMap { it.getDescriptors(kindFilter, nameFilter) }
-
 }