Partial compilation of package (only functions supported).

compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.jet.codegen;
 
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.util.io.FileUtil;
@@ -27,23 +29,32 @@ import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.AnnotationVisitor;
+import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.FieldOwnerContext;
+import org.jetbrains.jet.codegen.context.MethodContext;
+import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.codegen.context.PackageContext;
 import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.descriptors.serialization.*;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpleFunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.codegen.state.GenerationStateAware;
 import org.jetbrains.jet.descriptors.serialization.BitEncoding;
 import org.jetbrains.jet.descriptors.serialization.DescriptorSerializer;
 import org.jetbrains.jet.descriptors.serialization.PackageData;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
-import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.MemberComparator;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragmentScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -52,6 +63,7 @@ import java.util.*;
 import static org.jetbrains.asm4.Opcodes.*;
 import static org.jetbrains.jet.codegen.AsmUtil.asmDescByFqNameWithoutInnerClasses;
 import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
+import static org.jetbrains.jet.codegen.JvmSerializationBindings.METHOD_FOR_FUNCTION;
 import static org.jetbrains.jet.descriptors.serialization.NameSerializationUtil.createNameResolver;
 import static org.jetbrains.jet.lang.resolve.java.PackageClassUtils.getPackageClassFqName;
 
@@ -62,6 +74,7 @@ public class PackageCodegen extends GenerationStateAware {
     @NotNull
     private final Collection<JetFile> files;
     private final PackageFragmentDescriptor packageFragment;
+    private final PackageFragmentDescriptor compiledPackageFragment;
 
     public PackageCodegen(
             @NotNull ClassBuilderOnDemand v,
@@ -74,8 +87,10 @@ public class PackageCodegen extends GenerationStateAware {
         this.v = v;
         this.files = packageFiles;
         this.packageFragment = getOnlyPackageFragment();
+        this.compiledPackageFragment = getCompiledPackageFragment();
 
-        final PsiFile sourceFile = packageFiles.size() == 1 ? packageFiles.iterator().next().getContainingFile() : null;
+        final PsiFile sourceFile = packageFiles.size() == 1 && getAlreadyCompiledCallables().isEmpty()
+                                   ? packageFiles.iterator().next().getContainingFile() : null;
 
         v.addOptionalDeclaration(new ClassBuilderOnDemand.ClassBuilderCallback() {
             @Override
@@ -95,6 +110,69 @@ public class PackageCodegen extends GenerationStateAware {
         });
     }
 
+    @Nullable
+    private PackageFragmentDescriptor getCompiledPackageFragment() {
+        // TODO rewrite it to something more robust when module system is implemented
+        for (PackageFragmentDescriptor anotherFragment : packageFragment.getContainingDeclaration().getPackageFragmentProvider()
+                .getPackageFragments(packageFragment.getFqName())) {
+            if (anotherFragment.getMemberScope() instanceof LazyJavaPackageFragmentScope) {
+                return anotherFragment;
+            }
+        }
+        return null;
+    }
+
+    @NotNull
+    private List<CallableMemberDescriptor> getAlreadyCompiledCallables() {
+        List<CallableMemberDescriptor> callables = Lists.newArrayList();
+        if (compiledPackageFragment != null) {
+            for (DeclarationDescriptor member : compiledPackageFragment.getMemberScope().getAllDescriptors()) {
+                if (member instanceof DeserializedSimpleFunctionDescriptor) {
+                    callables.add((DeserializedSimpleFunctionDescriptor) member);
+                }
+            }
+        }
+        return callables;
+    }
+
+    private void generateDelegationsToAlreadyCompiled(Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks) {
+        for (final CallableMemberDescriptor member : getAlreadyCompiledCallables()) {
+            generateCallableMemberTasks.put(member, new Runnable() {
+                @Override
+                public void run() {
+                    DeserializedSimpleFunctionDescriptor deserializedFunction = (DeserializedSimpleFunctionDescriptor) member;
+
+                    FieldOwnerContext context = CodegenContext.STATIC.intoPackageFacade(
+                            Type.getObjectType(getPackagePartInternalName(deserializedFunction)),
+                            compiledPackageFragment);
+
+                    FunctionCodegen fuCo = new FunctionCodegen(
+                            context,
+                            v.getClassBuilder(),
+                            state,
+                            getMemberCodegen(context)
+                    );
+
+                    JvmMethodSignature signature = typeMapper.mapSignature(deserializedFunction, OwnerKind.PACKAGE);
+                    fuCo.generateMethod(null, signature, deserializedFunction,
+                                        new FunctionGenerationStrategy() {
+                                            @Override
+                                            public void generateBody(
+                                                    @NotNull MethodVisitor mv,
+                                                    @NotNull JvmMethodSignature signature,
+                                                    @NotNull MethodContext context,
+                                                    @Nullable MemberCodegen parentCodegen
+                                            ) {
+                                                throw new IllegalStateException("shouldn't be called");
+                                            }
+                                        });
+
+                    v.getClassBuilder().getSerializationBindings().put(METHOD_FOR_FUNCTION, deserializedFunction, signature.getAsmMethod());
+                }
+            });
+        }
+    }
+
     public void generate(@NotNull CompilationErrorHandler errorHandler) {
         List<JvmSerializationBindings> bindings = new ArrayList<JvmSerializationBindings>(files.size() + 1);
         boolean shouldGeneratePackageClass = shouldGeneratePackageClass(files);
@@ -102,9 +180,11 @@ public class PackageCodegen extends GenerationStateAware {
             bindings.add(v.getClassBuilder().getSerializationBindings());
         }
 
+        Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks = new HashMap<CallableMemberDescriptor, Runnable>();
+
         for (JetFile file : files) {
             try {
-                ClassBuilder builder = generate(file);
+                ClassBuilder builder = generate(file, generateCallableMemberTasks);
                 if (builder != null) {
                     bindings.add(builder.getSerializationBindings());
                 }
@@ -123,6 +203,15 @@ public class PackageCodegen extends GenerationStateAware {
             }
         }
 
+        if (shouldGeneratePackageClass) {
+            // Shouldn't generate delegations to previously compiled if we compile only "classes" part of a package.
+            generateDelegationsToAlreadyCompiled(generateCallableMemberTasks);
+        }
+
+        for (CallableMemberDescriptor member : Ordering.from(MemberComparator.INSTANCE).sortedCopy(generateCallableMemberTasks.keySet())) {
+            generateCallableMemberTasks.get(member).run();
+        }
+
         if (shouldGeneratePackageClass) {
             writeKotlinPackageAnnotationIfNeeded(JvmSerializationBindings.union(bindings));
         }
@@ -142,7 +231,10 @@ public class PackageCodegen extends GenerationStateAware {
         }
 
         DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(bindings));
-        ProtoBuf.Package packageProto = serializer.packageProto(Collections.singleton(packageFragment)).build();
+        Collection<PackageFragmentDescriptor> packageFragments = compiledPackageFragment == null
+                                                                 ? Collections.singleton(packageFragment)
+                                                                 : Arrays.asList(packageFragment, compiledPackageFragment);
+        ProtoBuf.Package packageProto = serializer.packageProto(packageFragments).build();
 
         if (packageProto.getMemberCount() == 0) return;
 
@@ -160,7 +252,7 @@ public class PackageCodegen extends GenerationStateAware {
     }
 
     @Nullable
-    private ClassBuilder generate(@NotNull JetFile file) {
+    private ClassBuilder generate(@NotNull JetFile file, @NotNull Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks) {
         boolean generateSrcClass = false;
         Type packagePartType = getPackagePartType(getPackageClassFqName(packageFragment.getFqName()), file.getVirtualFile());
         PackageContext packagePartContext = CodegenContext.STATIC.intoPackagePart(packageFragment, packagePartType);
@@ -187,22 +279,40 @@ public class PackageCodegen extends GenerationStateAware {
 
         new PackagePartCodegen(builder, file, packagePartType, packagePartContext, state).generate();
 
-        FieldOwnerContext packageFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, packageFragment);
+        final FieldOwnerContext packageFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, packageFragment);
-        //TODO: FIX: Default method generated at facade without delegation
+        
-        MemberCodegen memberCodegen = new MemberCodegen(state, null, packageFacade, null) {
+        final MemberCodegen memberCodegen = getMemberCodegen(packageFacade);
+
+        for (final JetDeclaration declaration : file.getDeclarations()) {
+            if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
+                DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
+                assert descriptor instanceof CallableMemberDescriptor :
+                        "Expected callable member, was " + descriptor + " for " + declaration.getText();
+                generateCallableMemberTasks.put(
+                        (CallableMemberDescriptor) descriptor,
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                memberCodegen.genFunctionOrProperty(
+                                        packageFacade, (JetTypeParameterListOwner) declaration, v.getClassBuilder());
+                            }
+                        }
+                );
+            }
+        }
+
+        return builder;
+    }
+
+    //TODO: FIX: Default method generated at facade without delegation
+    private MemberCodegen getMemberCodegen(@NotNull FieldOwnerContext packageFacade) {
+        return new MemberCodegen(state, null, packageFacade, null) {
             @NotNull
             @Override
             public ClassBuilder getBuilder() {
                 return v.getClassBuilder();
             }
         };
-        for (JetDeclaration declaration : file.getDeclarations()) {
-            if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
-                memberCodegen.genFunctionOrProperty(packageFacade, (JetTypeParameterListOwner) declaration, v.getClassBuilder());
-            }
-        }
-
-        return builder;
     }
 
     @NotNull
@@ -257,9 +367,11 @@ public class PackageCodegen extends GenerationStateAware {
         String srcName = facadeFqName.shortName().asString() + "-" + replaceSpecialSymbols(fileName) + "-" + Integer.toHexString(
                 CodegenUtil.getPathHashCode(file));
 
-        FqName srcFqName = facadeFqName.parent().child(Name.identifier(srcName));
+        return getPackagePartType(facadeFqName, Name.identifier(srcName));
+    }
 
-        return asmTypeByFqNameWithoutInnerClasses(srcFqName);
+    public static Type getPackagePartType(FqName facadeFqName, Name packagePartName) {
+        return asmTypeByFqNameWithoutInnerClasses(facadeFqName.parent().child(packagePartName));
     }
 
     @NotNull
@@ -272,4 +384,17 @@ public class PackageCodegen extends GenerationStateAware {
         FqName packageFqName = file.getPackageFqName();
         return getPackagePartType(getPackageClassFqName(packageFqName), file.getVirtualFile()).getInternalName();
     }
+
+    @NotNull
+    public static String getPackagePartInternalName(@NotNull DeserializedSimpleFunctionDescriptor deserializedFunction) {
+        DeclarationDescriptor parent = deserializedFunction.getContainingDeclaration();
+        assert parent instanceof PackageFragmentDescriptor : "parent should be package, but was: " + parent;
+
+        assert deserializedFunction.getFunctionProto().hasExtension(JavaProtoBuf.implClassName)
+                : "implClassName extension is absent for " + deserializedFunction;
+        Name shortName = deserializedFunction.getNameResolver()
+                .getName(deserializedFunction.getFunctionProto().getExtension(JavaProtoBuf.implClassName));
+        FqName packagePartFqName = ((PackageFragmentDescriptor) parent).getFqName().child(shortName);
+        return JvmClassName.byFqNameWithoutInnerClasses(packagePartFqName).getInternalName();
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.codegen.signature.BothSignatureWriter;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall;
@@ -126,13 +127,16 @@ public class JetTypeMapper extends BindingTraceAware {
         }
 
         // It's not a package created for Java class statics
-        JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
+        if (insideModule) {
-        if (insideModule && file != null) {
+            JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
-            return PackageCodegen.getPackagePartInternalName(file);
+            if (file != null) {
-        }
+                return PackageCodegen.getPackagePartInternalName(file);
-        else {
+            }
-            return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
+            if (descriptor instanceof DeserializedSimpleFunctionDescriptor) {
+                return PackageCodegen.getPackagePartInternalName((DeserializedSimpleFunctionDescriptor) descriptor);
+            }
         }
+        return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
     }
 
     @NotNull

compiler/cli/cli.iml

@@ -18,6 +18,8 @@
     <orderEntry type="module" module-name="descriptor.loader.java" />
     <orderEntry type="module" module-name="util" />
     <orderEntry type="module" module-name="backend-common" />
+    <orderEntry type="module" module-name="serialization" />
+    <orderEntry type="module" module-name="serialization.java" />
   </component>
 </module>
 

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliSourcesMemberFilter.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.cli.jvm.compiler
+
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf
+import org.jetbrains.jet.codegen.PackageCodegen.getPackagePartInternalName
+import org.jetbrains.jet.descriptors.serialization.NameResolver
+import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+import org.jetbrains.jet.lang.resolve.java.JvmClassName
+
+public class CliSourcesMemberFilter(environment: JetCoreEnvironment): MemberFilter {
+    val packagePartClassNames = environment.getSourceFiles().map { getPackagePartInternalName(it) }.toSet()
+
+    override fun acceptPackagePartClass(container: PackageFragmentDescriptor, member: ProtoBuf.Callable, nameResolver: NameResolver): Boolean {
+        if (member.hasExtension(JavaProtoBuf.implClassName)) {
+            val shortName = nameResolver.getName(member.getExtension(JavaProtoBuf.implClassName)!!)
+            val fqName = container.getFqName().child(shortName)
+            val internalName = JvmClassName.byFqNameWithoutInnerClasses(fqName).getInternalName()
+            return internalName !in packagePartClassNames
+        }
+        return true
+    }
+}

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java

@@ -301,6 +301,7 @@ public class JetCoreEnvironment {
         }
     }
 
+    @NotNull
     public List<JetFile> getSourceFiles() {
         return sourceFiles;
     }

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -275,8 +275,8 @@ public class KotlinToJVMBytecodeCompiler {
                                 environment.getConfiguration().getList(JVMConfigurationKeys.SCRIPT_PARAMETERS),
                                 Predicates.<PsiFile>alwaysTrue(),
                                 false,
-                                sharedModule
+                                sharedModule,
-                        );
+                                new CliSourcesMemberFilter(environment));
                     }
                 }, environment.getSourceFiles()
         );

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -43,6 +43,7 @@ import org.jetbrains.jet.codegen.CompilationErrorHandler;
 import org.jetbrains.jet.codegen.KotlinCodegenFacade;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
@@ -75,9 +76,7 @@ import java.util.List;
 
 import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.BINARIES;
+import static org.jetbrains.jet.lang.descriptors.DependencyKind.*;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.BUILT_INS;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.SOURCES;
 
 public class ReplInterpreter {
 
@@ -111,7 +110,7 @@ public class ReplInterpreter {
                 false,
                 true,
                 Collections.<AnalyzerScriptParameter>emptyList());
-        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
+        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module, MemberFilter.ALWAYS_TRUE);
         topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters);
         module.addFragmentProvider(SOURCES, injector.getTopDownAnalyzer().getPackageFragmentProvider());
         module.addFragmentProvider(BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
@@ -56,6 +57,7 @@ public class InjectorForJavaDescriptorResolver {
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final VirtualFileFinder virtualFileFinder;
+    private final MemberFilter memberFilter;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
@@ -84,6 +86,7 @@ public class InjectorForJavaDescriptorResolver {
         this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE;
         this.descriptorDeserializers = new DescriptorDeserializers();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
@@ -105,6 +108,7 @@ public class InjectorForJavaDescriptorResolver {
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setMemberFilter(memberFilter);
         deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.LazyResolveBasedCache;
@@ -73,6 +74,7 @@ public class InjectorForLazyResolveWithJava {
     private final ResolveSession resolveSession;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final VirtualFileFinder virtualFileFinder;
+    private final MemberFilter memberFilter;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final LazyResolveBasedCache lazyResolveBasedCache;
@@ -129,6 +131,7 @@ public class InjectorForLazyResolveWithJava {
         this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE;
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -224,6 +227,7 @@ public class InjectorForLazyResolveWithJava {
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setMemberFilter(memberFilter);
         deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
@@ -81,6 +82,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final TopDownAnalyzer topDownAnalyzer;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
+    private final MemberFilter memberFilter;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
@@ -128,7 +130,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         @NotNull Project project,
         @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl moduleDescriptor
+        @NotNull ModuleDescriptorImpl moduleDescriptor,
+        @NotNull MemberFilter memberFilter
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -138,6 +141,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
+        this.memberFilter = memberFilter;
         this.javaClassFinder = new JavaClassFinderImpl();
         this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
@@ -302,6 +306,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setMemberFilter(memberFilter);
         deserializedDescriptorResolver.setStorageManager(storageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);

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

@@ -28,6 +28,7 @@ import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
@@ -195,7 +196,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             boolean storeContextForBodiesResolve
     ) {
         return analyzeFilesWithJavaIntegration(project, files, trace, scriptParameters, filesToAnalyzeCompletely,
-                                               storeContextForBodiesResolve, createJavaModule("<module>"));
+                                               storeContextForBodiesResolve, createJavaModule("<module>"), MemberFilter.ALWAYS_TRUE);
     }
 
     @NotNull
@@ -206,11 +207,12 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             List<AnalyzerScriptParameter> scriptParameters,
             Predicate<PsiFile> filesToAnalyzeCompletely,
             boolean storeContextForBodiesResolve,
-            ModuleDescriptorImpl module
+            ModuleDescriptorImpl module,
+            MemberFilter memberFilter
     ) {
         GlobalContext globalContext = ContextPackage.GlobalContext();
         return analyzeFilesWithJavaIntegrationInGlobalContext(project, files, trace, scriptParameters, filesToAnalyzeCompletely,
-                                                              storeContextForBodiesResolve, module, globalContext);
+                                                              storeContextForBodiesResolve, module, globalContext, memberFilter);
     }
 
     @NotNull
@@ -222,7 +224,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             Predicate<PsiFile> filesToAnalyzeCompletely,
             boolean storeContextForBodiesResolve,
             ModuleDescriptorImpl module,
-            GlobalContext globalContext
+            GlobalContext globalContext,
+            MemberFilter memberFilter
     ) {
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 globalContext.getStorageManager(),
@@ -233,7 +236,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                 scriptParameters
         );
 
-        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
+        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module,
+                                                                                         memberFilter);
         try {
             module.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
             TopDownAnalysisContext topDownAnalysisContext = injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files);

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java

@@ -60,11 +60,11 @@ public abstract class DeserializedMemberScope implements JetScope {
     private final MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> properties;
     private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
 
-    public DeserializedMemberScope(
+    protected DeserializedMemberScope(
             @NotNull StorageManager storageManager,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull DescriptorDeserializer deserializer,
-            @NotNull List<ProtoBuf.Callable> membersList
+            @NotNull Collection<ProtoBuf.Callable> membersList
     ) {
         this.containingDeclaration = containingDeclaration;
         this.deserializer = deserializer;
@@ -245,4 +245,4 @@ public abstract class DeserializedMemberScope implements JetScope {
         p.popIndent();
         p.println("}");
     }
-}
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.descriptors.serialization.descriptors;
 
+import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
@@ -26,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
+import java.util.List;
 
 public class DeserializedPackageMemberScope extends DeserializedMemberScope {
     private final DescriptorFinder descriptorFinder;
@@ -36,13 +38,14 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
             @NotNull StorageManager storageManager,
             @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull Deserializers deserializers,
+            @NotNull MemberFilter memberFilter,
             @NotNull DescriptorFinder descriptorFinder,
             @NotNull ProtoBuf.Package proto,
             @NotNull NameResolver nameResolver
     ) {
         super(storageManager, packageDescriptor,
               DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, deserializers),
-              proto.getMemberList());
+              getFilteredMembers(packageDescriptor, proto, memberFilter, nameResolver));
         this.descriptorFinder = descriptorFinder;
         this.packageFqName = packageDescriptor.getFqName();
     }
@@ -51,10 +54,11 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
             @NotNull StorageManager storageManager,
             @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull Deserializers deserializers,
+            @NotNull MemberFilter memberFilter,
             @NotNull DescriptorFinder descriptorFinder,
             @NotNull PackageData packageData
     ) {
-        this(storageManager, packageDescriptor, deserializers, descriptorFinder, packageData.getPackageProto(),
+        this(storageManager, packageDescriptor, deserializers, memberFilter, descriptorFinder, packageData.getPackageProto(),
              packageData.getNameResolver());
     }
 
@@ -85,4 +89,20 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
     protected ReceiverParameterDescriptor getImplicitReceiver() {
         return null;
     }
+
+    @NotNull
+    private static Collection<ProtoBuf.Callable> getFilteredMembers(
+            @NotNull PackageFragmentDescriptor packageDescriptor,
+            @NotNull ProtoBuf.Package packageProto,
+            @NotNull MemberFilter memberFilter,
+            @NotNull NameResolver nameResolver
+    ) {
+        List<ProtoBuf.Callable> result = Lists.newArrayList();
+        for (ProtoBuf.Callable member : packageProto.getMemberList()) {
+            if (memberFilter.acceptPackagePartClass(packageDescriptor, member, nameResolver)) {
+                result.add(member);
+            }
+        }
+        return result;
+    }
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/MemberFilter.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.descriptors.serialization.descriptors
+
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf
+import org.jetbrains.jet.descriptors.serialization.NameResolver
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+
+public trait MemberFilter {
+    fun acceptPackagePartClass(container: PackageFragmentDescriptor, member: ProtoBuf.Callable, nameResolver: NameResolver): Boolean
+
+    class object {
+        public val ALWAYS_TRUE: MemberFilter = object : MemberFilter {
+            override fun acceptPackagePartClass(container: PackageFragmentDescriptor, member: ProtoBuf.Callable, nameResolver: NameResolver): Boolean = true
+        }
+    }
+}

compiler/testData/asJava/nullabilityAnnotations/_DefaultPackage.java

@@ -1,46 +1,17 @@
 public final class _DefaultPackage {
-    @org.jetbrains.annotations.NotNull
-    public static final java.lang.String notNull(@org.jetbrains.annotations.NotNull @jet.runtime.typeinfo.JetValueParameter(name = "a") java.lang.String a) { /* compiled code */ }
-
-    @org.jetbrains.annotations.Nullable
-    public static final java.lang.String nullable(@org.jetbrains.annotations.Nullable @jet.runtime.typeinfo.JetValueParameter(name = "a", type = "?") java.lang.String a) { /* compiled code */ }
-
-    @org.jetbrains.annotations.NotNull
-    public static final java.lang.String notNullWithNN() { /* compiled code */ }
-
-    @org.jetbrains.annotations.Nullable
-    @org.jetbrains.annotations.NotNull
-    public static final java.lang.String notNullWithN() { /* compiled code */ }
-
-    @org.jetbrains.annotations.Nullable
-    public static final java.lang.String nullableWithN() { /* compiled code */ }
-
-    @org.jetbrains.annotations.NotNull
-    @org.jetbrains.annotations.Nullable
-    public static final java.lang.String nullableWithNN() { /* compiled code */ }
-
-    @org.jetbrains.annotations.Nullable
-    public static final java.lang.String getNullableVal() { /* compiled code */ }
-
-    @org.jetbrains.annotations.Nullable
-    public static final java.lang.String getNullableVar() { /* compiled code */ }
-
-    @org.jetbrains.annotations.NotNull
-    public static final void setNullableVar(@org.jetbrains.annotations.Nullable @jet.runtime.typeinfo.JetValueParameter(name = "<set-?>", type = "?") java.lang.String p) { /* compiled code */ }
-
     @org.jetbrains.annotations.NotNull
     public static final java.lang.String getNotNullVal() { /* compiled code */ }
 
+    @org.jetbrains.annotations.Nullable
+    @org.jetbrains.annotations.NotNull
+    public static final java.lang.String getNotNullValWithGet() { /* compiled code */ }
+
     @org.jetbrains.annotations.NotNull
     public static final java.lang.String getNotNullVar() { /* compiled code */ }
 
     @org.jetbrains.annotations.NotNull
     public static final void setNotNullVar(@org.jetbrains.annotations.NotNull @jet.runtime.typeinfo.JetValueParameter(name = "<set-?>") java.lang.String p) { /* compiled code */ }
 
-    @org.jetbrains.annotations.Nullable
-    @org.jetbrains.annotations.NotNull
-    public static final java.lang.String getNotNullValWithGet() { /* compiled code */ }
-
     @org.jetbrains.annotations.Nullable
     @org.jetbrains.annotations.NotNull
     public static final java.lang.String getNotNullVarWithGetSet() { /* compiled code */ }
@@ -49,10 +20,19 @@ public final class _DefaultPackage {
     @org.jetbrains.annotations.NotNull
     public static final void setNotNullVarWithGetSet(@org.jetbrains.annotations.NotNull @jet.runtime.typeinfo.JetValueParameter(name = "v") java.lang.String v) { /* compiled code */ }
 
+    @org.jetbrains.annotations.Nullable
+    public static final java.lang.String getNullableVal() { /* compiled code */ }
+
     @org.jetbrains.annotations.NotNull
     @org.jetbrains.annotations.Nullable
     public static final java.lang.String getNullableValWithGet() { /* compiled code */ }
 
+    @org.jetbrains.annotations.Nullable
+    public static final java.lang.String getNullableVar() { /* compiled code */ }
+
+    @org.jetbrains.annotations.NotNull
+    public static final void setNullableVar(@org.jetbrains.annotations.Nullable @jet.runtime.typeinfo.JetValueParameter(name = "<set-?>", type = "?") java.lang.String p) { /* compiled code */ }
+
     @org.jetbrains.annotations.NotNull
     @org.jetbrains.annotations.Nullable
     public static final java.lang.String getNullableVarWithGetSet() { /* compiled code */ }
@@ -60,11 +40,31 @@ public final class _DefaultPackage {
     @org.jetbrains.annotations.NotNull
     public static final void setNullableVarWithGetSet(@org.jetbrains.annotations.Nullable @jet.runtime.typeinfo.JetValueParameter(name = "v", type = "?") java.lang.String v) { /* compiled code */ }
 
+    @org.jetbrains.annotations.Nullable
+    public static final java.lang.String getPrivateN() { /* compiled code */ }
+
     @org.jetbrains.annotations.NotNull
     public static final java.lang.String getPrivateNn() { /* compiled code */ }
 
+    @org.jetbrains.annotations.NotNull
+    public static final java.lang.String notNull(@org.jetbrains.annotations.NotNull @jet.runtime.typeinfo.JetValueParameter(name = "a") java.lang.String a) { /* compiled code */ }
+
     @org.jetbrains.annotations.Nullable
-    public static final java.lang.String getPrivateN() { /* compiled code */ }
+    @org.jetbrains.annotations.NotNull
+    public static final java.lang.String notNullWithN() { /* compiled code */ }
+
+    @org.jetbrains.annotations.NotNull
+    public static final java.lang.String notNullWithNN() { /* compiled code */ }
+
+    @org.jetbrains.annotations.Nullable
+    public static final java.lang.String nullable(@org.jetbrains.annotations.Nullable @jet.runtime.typeinfo.JetValueParameter(name = "a", type = "?") java.lang.String a) { /* compiled code */ }
+
+    @org.jetbrains.annotations.Nullable
+    public static final java.lang.String nullableWithN() { /* compiled code */ }
+
+    @org.jetbrains.annotations.NotNull
+    @org.jetbrains.annotations.Nullable
+    public static final java.lang.String nullableWithNN() { /* compiled code */ }
 
     @org.jetbrains.annotations.Nullable
     public static final java.lang.String privateFun(@org.jetbrains.annotations.NotNull @jet.runtime.typeinfo.JetValueParameter(name = "a") java.lang.String a, @org.jetbrains.annotations.Nullable @jet.runtime.typeinfo.JetValueParameter(name = "b", type = "?") java.lang.String b) { /* compiled code */ }

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

@@ -22,6 +22,7 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -47,7 +48,8 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
 
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                 getProject(), jetFiles, support.getTrace(),
-                Collections.<AnalyzerScriptParameter>emptyList(), Predicates.<PsiFile>alwaysTrue(), false, support.getModule()).getBindingContext();
+                Collections.<AnalyzerScriptParameter>emptyList(), Predicates.<PsiFile>alwaysTrue(), false, support.getModule(),
+                MemberFilter.ALWAYS_TRUE).getBindingContext();
 
         boolean ok = true;
 

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

@@ -32,6 +32,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.*;
@@ -152,7 +153,8 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 environment.getProject(),
                 parameters,
                 trace,
-                module);
+                module,
+                MemberFilter.ALWAYS_TRUE);
 
         module.addFragmentProvider(DependencyKind.BINARIES, injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider());
 

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -60,7 +61,7 @@ public class LazyResolveTestUtil {
         ModuleDescriptorImpl sharedModule = support.getModule();
 
         InjectorForTopDownAnalyzerForJvm injector =
-                new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule);
+                new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule, MemberFilter.ALWAYS_TRUE);
         sharedModule.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
         injector.getTopDownAnalyzer().analyzeFiles(params, files);
         return injector.getModuleDescriptor();

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.descriptors.serialization.DescriptorFinder;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -45,6 +46,8 @@ import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kin
 public final class DeserializedDescriptorResolver {
     private DescriptorDeserializers annotationDeserializer;
 
+    private MemberFilter memberFilter;
+
     private StorageManager storageManager;
 
     private JavaPackageFragmentProvider javaPackageFragmentProvider;
@@ -73,6 +76,11 @@ public final class DeserializedDescriptorResolver {
         this.annotationDeserializer = annotationDeserializer;
     }
 
+    @Inject
+    public void setMemberFilter(MemberFilter memberFilter) {
+        this.memberFilter = memberFilter;
+    }
+
     @Inject
     public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) {
         this.javaPackageFragmentProvider = javaPackageFragmentProvider;
@@ -108,8 +116,8 @@ public final class DeserializedDescriptorResolver {
     public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass, PACKAGE_FACADE);
         if (data != null) {
-            return new DeserializedPackageMemberScope(storageManager, descriptor, annotationDeserializer, javaDescriptorFinder,
+            return new DeserializedPackageMemberScope(storageManager, descriptor, annotationDeserializer,
-                                                      JavaProtoBufUtil.readPackageDataFrom(data));
+                                                      memberFilter, javaDescriptorFinder, JavaProtoBufUtil.readPackageDataFrom(data));
         }
         return null;
     }

core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java

@@ -6,6 +6,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
 import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
@@ -39,7 +40,7 @@ class BuiltinsPackageFragment extends DeclarationDescriptorImpl implements Packa
         packageFragmentProvider = new BuiltinsPackageFragmentProvider();
 
         // TODO: support annotations
-        members = new DeserializedPackageMemberScope(storageManager, this, Deserializers.UNSUPPORTED,
+        members = new DeserializedPackageMemberScope(storageManager, this, Deserializers.UNSUPPORTED, MemberFilter.ALWAYS_TRUE,
                                                      new BuiltInsDescriptorFinder(storageManager), loadPackage(), nameResolver);
     }
 

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices
 import org.jetbrains.jet.di.*
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils
-import org.jetbrains.jet.context.SimpleGlobalContext
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
 
 // NOTE: After making changes, you need to re-generate the injectors.
 //       To do that, you can run main in this file.
@@ -94,6 +94,8 @@ private fun generatorForTopDownAnalyzerForJvm() =
             implementInterface(javaClass<InjectorForTopDownAnalyzer>())
             commonForTopDownAnalyzer()
 
+            parameter(javaClass<MemberFilter>())
+
             publicField(javaClass<JavaDescriptorResolver>())
 
             fields(
@@ -131,6 +133,8 @@ private fun generatorForJavaDescriptorResolver() =
             )
             field(javaClass<VirtualFileFinder>(),
                   init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
+            field(javaClass<MemberFilter>(),
+                  init = GivenExpression(javaClass<MemberFilter>().getName() + ".ALWAYS_TRUE"))
         }
 
 private fun generatorForLazyResolveWithJava() =
@@ -151,6 +155,8 @@ private fun generatorForLazyResolveWithJava() =
 
             field(javaClass<VirtualFileFinder>(),
                   init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
+            field(javaClass<MemberFilter>(),
+                  init = GivenExpression(javaClass<MemberFilter>().getName() + ".ALWAYS_TRUE"))
             fields(
                     javaClass<JavaClassFinderImpl>(),
                     javaClass<TraceBasedExternalSignatureResolver>(),

idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt

@@ -43,6 +43,7 @@ import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage
 import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
 
 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
     val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
@@ -69,6 +70,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
                 storageManager,
                 createDummyPackageFragment(packageFqName),
                 deserializers,
+                MemberFilter.ALWAYS_TRUE,
                 descriptorFinder,
                 JavaProtoBufUtil.readPackageDataFrom(annotationData)
         )

idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java

@@ -37,6 +37,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContext;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetElement;
@@ -201,7 +202,8 @@ public final class AnalyzerFacadeWithCache {
                                 Predicates.<PsiFile>alwaysFalse(),
                                 true,
                                 AnalyzerFacadeForJVM.createJavaModule("<module>"),
-                                globalContext
+                                globalContext,
+                                MemberFilter.ALWAYS_TRUE
                         );
             }
 

jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java

@@ -191,6 +191,10 @@ public class KotlinBuilder extends ModuleLevelBuilder {
         }
 
         for (SimpleOutputItem outputItem : outputItemCollector.getOutputs()) {
+            // TODO this is a hack: we don't remove
+            if (outputItem.getOutputFile().getName().endsWith("Package.class")) {
+                continue;
+            }
             BuildTarget<?> target = null;
             Collection<File> sourceFiles = outputItem.getSourceFiles();
             if (sourceFiles != null && !sourceFiles.isEmpty()) {
@@ -200,7 +204,8 @@ public class KotlinBuilder extends ModuleLevelBuilder {
                 messageCollector.report(EXCEPTION, "KotlinBuilder: outputItem.sourceFiles is null or empty, outputItem = " + outputItem, NO_LOCATION);
             }
 
-            outputConsumer.registerOutputFile(target != null ? target : representativeTarget, outputItem.getOutputFile(), paths(sourceFiles));
+            outputConsumer.registerOutputFile(target != null ? target : representativeTarget, outputItem.getOutputFile(),
+                                              paths(sourceFiles));
         }
 
         // TODO should mark dependencies as dirty, as well

jps-plugin/test/org/jetbrains/jet/jps/build/IncrementalJpsTest.kt

@@ -98,6 +98,10 @@ public class IncrementalJpsTest : JpsBuildTestCase() {
         doTest()
     }
 
+    fun testTopLevelMembersInTwoPackages() {
+        doTest()
+    }
+
     private class MyLogger(val rootPath: String) : ProjectBuilderLoggerBase() {
         private val logBuf = StringBuilder()
         public val log: String

jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt

@@ -0,0 +1,9 @@
+package test
+
+fun foo() {
+    bar(5)
+    baz()
+}
+
+fun baz() {
+}

jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt.new

@@ -0,0 +1,9 @@
+package test
+
+fun foo() {
+    bar(4)
+    baz()
+}
+
+fun baz() {
+}

jps-plugin/testData/incremental/topLevelMembersInTwoPackages/b.kt

@@ -0,0 +1,9 @@
+package test
+
+fun bar(i: Int): String {
+    return "$i   ${quux()}   $i"
+}
+
+fun quux(): String {
+    return "quux"
+}

jps-plugin/testData/incremental/topLevelMembersInTwoPackages/build.log

@@ -0,0 +1,12 @@
+Cleaning output files:
+out/production/module/test/TestPackage-a-*.class
+End of files
+Compiling files:
+src/a.kt
+End of files
+Cleaning output files:
+out/production/module/test/TestPackage-b-*.class
+End of files
+Compiling files:
+src/b.kt
+End of files