diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java index c5979138626..acecc7caec4 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java +++ b/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 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 getAlreadyCompiledCallables() { + List 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 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 bindings = new ArrayList(files.size() + 1); boolean shouldGeneratePackageClass = shouldGeneratePackageClass(files); @@ -102,9 +180,11 @@ public class PackageCodegen extends GenerationStateAware { bindings.add(v.getClassBuilder().getSerializationBindings()); } + Map generateCallableMemberTasks = new HashMap(); + 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 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 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); - //TODO: FIX: Default method generated at facade without delegation - MemberCodegen memberCodegen = new MemberCodegen(state, null, packageFacade, null) { + final FieldOwnerContext packageFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, packageFragment); + + 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(); + } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 2289f98d4b9..f5647a1b720 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/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 && file != null) { - return PackageCodegen.getPackagePartInternalName(file); - } - else { - return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/'); + if (insideModule) { + JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor); + if (file != null) { + return PackageCodegen.getPackagePartInternalName(file); + } + if (descriptor instanceof DeserializedSimpleFunctionDescriptor) { + return PackageCodegen.getPackagePartInternalName((DeserializedSimpleFunctionDescriptor) descriptor); + } } + return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/'); } @NotNull diff --git a/compiler/cli/cli.iml b/compiler/cli/cli.iml index a8b242b3638..d09bef5e906 100644 --- a/compiler/cli/cli.iml +++ b/compiler/cli/cli.iml @@ -18,6 +18,8 @@ + + diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliSourcesMemberFilter.kt b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliSourcesMemberFilter.kt new file mode 100644 index 00000000000..aeb6e010df0 --- /dev/null +++ b/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 + } +} \ No newline at end of file diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java index 29908780f6e..477691d9e37 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java @@ -301,6 +301,7 @@ public class JetCoreEnvironment { } } + @NotNull public List getSourceFiles() { return sourceFiles; } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 4905fa21640..ceae5ca3def 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/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.alwaysTrue(), false, - sharedModule - ); + sharedModule, + new CliSourcesMemberFilter(environment)); } }, environment.getSourceFiles() ); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index 83745cce09c..e94f119d0ed 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/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.BUILT_INS; -import static org.jetbrains.jet.lang.descriptors.DependencyKind.SOURCES; +import static org.jetbrains.jet.lang.descriptors.DependencyKind.*; public class ReplInterpreter { @@ -111,7 +110,7 @@ public class ReplInterpreter { false, true, Collections.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()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 4a458d4ac60..18c2259a602 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 1e562e0f172..c58c6b528f5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 6ab150f4aac..69909be4cce 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 4d8fa9b9dfd..ac93445ea7e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/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("")); + storeContextForBodiesResolve, createJavaModule(""), MemberFilter.ALWAYS_TRUE); } @NotNull @@ -206,11 +207,12 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { List scriptParameters, Predicate 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 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); diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java index a8c36213a31..57837058237 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java +++ b/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> properties; private final NotNullLazyValue> allDescriptors; - public DeserializedMemberScope( + protected DeserializedMemberScope( @NotNull StorageManager storageManager, @NotNull DeclarationDescriptor containingDeclaration, @NotNull DescriptorDeserializer deserializer, - @NotNull List membersList + @NotNull Collection membersList ) { this.containingDeclaration = containingDeclaration; this.deserializer = deserializer; @@ -245,4 +245,4 @@ public abstract class DeserializedMemberScope implements JetScope { p.popIndent(); p.println("}"); } -} \ No newline at end of file +} diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java index a146735ce53..169cb4f359b 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java +++ b/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 getFilteredMembers( + @NotNull PackageFragmentDescriptor packageDescriptor, + @NotNull ProtoBuf.Package packageProto, + @NotNull MemberFilter memberFilter, + @NotNull NameResolver nameResolver + ) { + List result = Lists.newArrayList(); + for (ProtoBuf.Callable member : packageProto.getMemberList()) { + if (memberFilter.acceptPackagePartClass(packageDescriptor, member, nameResolver)) { + result.add(member); + } + } + return result; + } } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/MemberFilter.kt b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/MemberFilter.kt new file mode 100644 index 00000000000..1aa333db7fa --- /dev/null +++ b/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 + } + } +} \ No newline at end of file diff --git a/compiler/testData/asJava/nullabilityAnnotations/_DefaultPackage.java b/compiler/testData/asJava/nullabilityAnnotations/_DefaultPackage.java index 7922b6f20db..49af58748db 100644 --- a/compiler/testData/asJava/nullabilityAnnotations/_DefaultPackage.java +++ b/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 = "", 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 = "") 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 = "", 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 */ } diff --git a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java index c52b33aae7c..0a3e2bae181 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java +++ b/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.emptyList(), Predicates.alwaysTrue(), false, support.getModule()).getBindingContext(); + Collections.emptyList(), Predicates.alwaysTrue(), false, support.getModule(), + MemberFilter.ALWAYS_TRUE).getBindingContext(); boolean ok = true; diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index 3312d882d9f..97b8bc14c94 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/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()); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 1cf0f53096d..83bab6dcc67 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/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(); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java index 89899079dde..51c1b05e3b9 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java +++ b/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, - JavaProtoBufUtil.readPackageDataFrom(data)); + return new DeserializedPackageMemberScope(storageManager, descriptor, annotationDeserializer, + memberFilter, javaDescriptorFinder, JavaProtoBufUtil.readPackageDataFrom(data)); } return null; } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java index 3c2edbc17a7..483c964a88f 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java +++ b/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); } diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 6968b7479a2..ce810809741 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/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()) commonForTopDownAnalyzer() + parameter(javaClass()) + publicField(javaClass()) fields( @@ -131,6 +133,8 @@ private fun generatorForJavaDescriptorResolver() = ) field(javaClass(), init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".ALWAYS_TRUE")) } private fun generatorForLazyResolveWithJava() = @@ -151,6 +155,8 @@ private fun generatorForLazyResolveWithJava() = field(javaClass(), init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".ALWAYS_TRUE")) fields( javaClass(), javaClass(), diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt index 8457cebb259..c0040d62304 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt +++ b/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) ) diff --git a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java index 608f372fa95..2972bb4cd6a 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java +++ b/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.alwaysFalse(), true, AnalyzerFacadeForJVM.createJavaModule(""), - globalContext + globalContext, + MemberFilter.ALWAYS_TRUE ); } diff --git a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java index dfa5db0a8ae..2b6607c95df 100644 --- a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java +++ b/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 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 diff --git a/jps-plugin/test/org/jetbrains/jet/jps/build/IncrementalJpsTest.kt b/jps-plugin/test/org/jetbrains/jet/jps/build/IncrementalJpsTest.kt index 0823675e211..1e3f934f02c 100644 --- a/jps-plugin/test/org/jetbrains/jet/jps/build/IncrementalJpsTest.kt +++ b/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 diff --git a/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt b/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt new file mode 100644 index 00000000000..0aae67fb7fd --- /dev/null +++ b/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt @@ -0,0 +1,9 @@ +package test + +fun foo() { + bar(5) + baz() +} + +fun baz() { +} diff --git a/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt.new b/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt.new new file mode 100644 index 00000000000..5e5e3542b2c --- /dev/null +++ b/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/a.kt.new @@ -0,0 +1,9 @@ +package test + +fun foo() { + bar(4) + baz() +} + +fun baz() { +} diff --git a/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/b.kt b/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/b.kt new file mode 100644 index 00000000000..0790fb178f1 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/build.log b/jps-plugin/testData/incremental/topLevelMembersInTwoPackages/build.log new file mode 100644 index 00000000000..37736142dc4 --- /dev/null +++ b/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