diff --git a/build.xml b/build.xml index 2e7d6e393da..e981cd215a2 100644 --- a/build.xml +++ b/build.xml @@ -125,7 +125,6 @@ - diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java index bdddd861162..4259c6f290f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.codegen; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.org.objectweb.asm.*; import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotated; @@ -30,7 +29,6 @@ import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetModifierList; import org.jetbrains.jet.lang.psi.JetModifierListOwner; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.constants.StringValue; @@ -38,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.org.objectweb.asm.*; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @@ -46,7 +45,34 @@ import java.util.*; import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration; public abstract class AnnotationCodegen { - public static final FqName VOLATILE_FQ_NAME = new FqName("kotlin.volatile"); + + public static final class JvmFlagAnnotation { + private final FqName fqName; + private final int jvmFlag; + + public JvmFlagAnnotation(@NotNull String fqName, int jvmFlag) { + this.fqName = new FqName(fqName); + this.jvmFlag = jvmFlag; + } + + public boolean hasAnnotation(@NotNull Annotated annotated) { + return annotated.getAnnotations().findAnnotation(fqName) != null; + } + + public int getJvmFlag() { + return jvmFlag; + } + } + + public static final List FIELD_FLAGS = Arrays.asList( + new JvmFlagAnnotation("kotlin.jvm.volatile", Opcodes.ACC_VOLATILE), + new JvmFlagAnnotation("kotlin.jvm.transient", Opcodes.ACC_TRANSIENT) + ); + + public static final List METHOD_FLAGS = Arrays.asList( + new JvmFlagAnnotation("kotlin.jvm.strictfp", Opcodes.ACC_STRICT), + new JvmFlagAnnotation("kotlin.jvm.synchronized", Opcodes.ACC_SYNCHRONIZED) + ); private static final AnnotationVisitor NO_ANNOTATION_VISITOR = new AnnotationVisitor(Opcodes.ASM5) {}; @@ -91,7 +117,6 @@ public abstract class AnnotationCodegen { AnnotationDescriptor annotationDescriptor = bindingContext.get(BindingContext.ANNOTATION, annotationEntry); if (annotationDescriptor == null) continue; // Skipping annotations if they are not resolved. Needed for JetLightClass generation - if (isVolatile(annotationDescriptor)) continue; String descriptor = genAnnotation(annotationDescriptor); if (descriptor != null) { @@ -149,11 +174,6 @@ public abstract class AnnotationCodegen { return !type.isNullable() && classifier instanceof TypeParameterDescriptor && TypeUtils.hasNullableSuperType(type); } - private static boolean isVolatile(@NotNull AnnotationDescriptor annotationDescriptor) { - ClassifierDescriptor classDescriptor = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor(); - return classDescriptor != null && DescriptorUtils.getFqName(classDescriptor).equals(VOLATILE_FQ_NAME.toUnsafe()); - } - public void generateAnnotationDefaultValue(@NotNull CompileTimeConstant value, @NotNull JetType expectedType) { AnnotationVisitor visitor = visitAnnotation(null, false); // Parameters are unimportant genCompileTimeValue(null, value, expectedType, visitor); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 26c40aea5ca..c2c133a3d66 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -169,6 +169,12 @@ public class AsmUtil { public static int getMethodAsmFlags(FunctionDescriptor functionDescriptor, OwnerKind kind) { int flags = getCommonCallableFlags(functionDescriptor); + for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.METHOD_FLAGS) { + if (flagAnnotation.hasAnnotation(functionDescriptor.getOriginal())) { + flags |= flagAnnotation.getJvmFlag(); + } + } + if (functionDescriptor.getModality() == Modality.FINAL && !(functionDescriptor instanceof ConstructorDescriptor)) { DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration(); if (!(containingDeclaration instanceof ClassDescriptor) || diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 18f022d423d..5e447daaf38 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -189,8 +189,10 @@ public class PropertyCodegen { private FieldVisitor generateBackingField(JetNamedDeclaration element, PropertyDescriptor propertyDescriptor, boolean isDelegate, JetType jetType, Object defaultValue) { int modifiers = getDeprecatedAccessFlag(propertyDescriptor); - if (propertyDescriptor.getOriginal().getAnnotations().findAnnotation(AnnotationCodegen.VOLATILE_FQ_NAME) != null) { - modifiers |= ACC_VOLATILE; + for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.FIELD_FLAGS) { + if (flagAnnotation.hasAnnotation(propertyDescriptor.getOriginal())) { + modifiers |= flagAnnotation.getJvmFlag(); + } } if (kind == OwnerKind.PACKAGE) { 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 2f73d6adbc3..7a41789091f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -33,10 +33,11 @@ import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; 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; -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; -import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder; +import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; -import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -61,10 +62,11 @@ public class InjectorForJavaDescriptorResolver { private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; - private final DescriptorDeserializers descriptorDeserializers; - private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; + private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; + private final JavaDescriptorFinder javaDescriptorFinder; + private final AnnotationDescriptorLoader annotationDescriptorLoader; private final DescriptorDeserializersStorage descriptorDeserializersStorage; - private final ConstantDescriptorDeserializer constantDescriptorDeserializer; + private final ConstantDescriptorLoader constantDescriptorLoader; public InjectorForJavaDescriptorResolver( @NotNull Project project, @@ -87,10 +89,11 @@ public class InjectorForJavaDescriptorResolver { this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule()); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule()); - this.descriptorDeserializers = new DescriptorDeserializers(); - this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); + this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider); + this.annotationDescriptorLoader = new AnnotationDescriptorLoader(); + this.constantDescriptorLoader = new ConstantDescriptorLoader(); + this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider); this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); - this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); this.javaClassFinder.setProject(project); @@ -105,27 +108,21 @@ public class InjectorForJavaDescriptorResolver { psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - deserializedDescriptorResolver.setDeserializers(descriptorDeserializers); + deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); - deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver); - deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider); - deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager); - descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); - descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); - - annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); - annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); - annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); - annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + annotationDescriptorLoader.setClassResolver(javaDescriptorResolver); + annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter); + annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder); + annotationDescriptorLoader.setStorage(descriptorDeserializersStorage); descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver); descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter); - constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver); - constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); - constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); - constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + constantDescriptorLoader.setClassResolver(javaDescriptorResolver); + constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter); + constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder); + constantDescriptorLoader.setStorage(descriptorDeserializersStorage); javaClassFinder.initialize(); 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 4073d7ee699..b6544c082b3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -55,10 +55,11 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; 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; -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; -import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder; +import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; -import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -105,10 +106,11 @@ public class InjectorForLazyResolveWithJava { private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; - private final DescriptorDeserializers descriptorDeserializers; - private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; + private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; + private final JavaDescriptorFinder javaDescriptorFinder; + private final AnnotationDescriptorLoader annotationDescriptorLoader; private final DescriptorDeserializersStorage descriptorDeserializersStorage; - private final ConstantDescriptorDeserializer constantDescriptorDeserializer; + private final ConstantDescriptorLoader constantDescriptorLoader; public InjectorForLazyResolveWithJava( @NotNull Project project, @@ -155,10 +157,11 @@ public class InjectorForLazyResolveWithJava { this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); this.scriptBodyResolver = new ScriptBodyResolver(); - this.descriptorDeserializers = new DescriptorDeserializers(); - this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); + this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider); + this.annotationDescriptorLoader = new AnnotationDescriptorLoader(); + this.constantDescriptorLoader = new ConstantDescriptorLoader(); + this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider); this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); - this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); @@ -235,27 +238,21 @@ public class InjectorForLazyResolveWithJava { scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); - deserializedDescriptorResolver.setDeserializers(descriptorDeserializers); + deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); - deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver); - deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider); - deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager); - descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); - descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); - - annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); - annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); - annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); - annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + annotationDescriptorLoader.setClassResolver(javaDescriptorResolver); + annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter); + annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder); + annotationDescriptorLoader.setStorage(descriptorDeserializersStorage); descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver); descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter); - constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver); - constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); - constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); - constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + constantDescriptorLoader.setClassResolver(javaDescriptorResolver); + constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter); + constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder); + constantDescriptorLoader.setStorage(descriptorDeserializersStorage); javaClassFinder.initialize(); 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 44164928dfe..cec7ca9a1ae 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; 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.TraceBasedJavaResolverCache; @@ -59,16 +59,17 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; 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; -import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder; +import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; -import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -86,7 +87,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final JavaDescriptorResolver javaDescriptorResolver; - private final DescriptorDeserializers descriptorDeserializers; + private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; private final JavaClassFinderImpl javaClassFinder; private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; private final TraceBasedJavaResolverCache traceBasedJavaResolverCache; @@ -119,16 +120,17 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final DeclarationResolver declarationResolver; private final ImportsResolver importsResolver; private final JetImportsFactory jetImportsFactory; - private final ScriptHeaderResolver scriptHeaderResolver; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; - private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; + private final JavaDescriptorFinder javaDescriptorFinder; + private final AnnotationDescriptorLoader annotationDescriptorLoader; private final DescriptorDeserializersStorage descriptorDeserializersStorage; - private final ConstantDescriptorDeserializer constantDescriptorDeserializer; + private final ConstantDescriptorLoader constantDescriptorLoader; public InjectorForTopDownAnalyzerForJvm( @NotNull Project project, @@ -157,7 +159,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor()); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor()); - this.descriptorDeserializers = new DescriptorDeserializers(); + this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider); + this.annotationDescriptorLoader = new AnnotationDescriptorLoader(); + this.constantDescriptorLoader = new ConstantDescriptorLoader(); + this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider); this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -182,13 +187,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.declarationResolver = new DeclarationResolver(); this.importsResolver = new ImportsResolver(); this.jetImportsFactory = new JetImportsFactory(); - this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); - this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager); - this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); @@ -208,9 +211,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); this.lazyTopDownAnalyzer.setTrace(bindingTrace); - this.descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); - this.descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); - javaClassFinder.setProject(project); traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); @@ -296,7 +296,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); - declarationResolver.setScriptHeaderResolver(scriptHeaderResolver); declarationResolver.setTrace(bindingTrace); importsResolver.setImportsFactory(jetImportsFactory); @@ -306,9 +305,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly jetImportsFactory.setProject(project); - scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - scriptHeaderResolver.setTrace(bindingTrace); - overloadResolver.setTrace(bindingTrace); overrideResolver.setTrace(bindingTrace); @@ -319,24 +315,24 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); - deserializedDescriptorResolver.setDeserializers(descriptorDeserializers); - deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); - deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver); - deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider); - deserializedDescriptorResolver.setStorageManager(storageManager); + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); - annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); - annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); - annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); - annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava); + deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); + + annotationDescriptorLoader.setClassResolver(javaDescriptorResolver); + annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter); + annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder); + annotationDescriptorLoader.setStorage(descriptorDeserializersStorage); descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver); descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter); - constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver); - constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); - constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); - constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + constantDescriptorLoader.setClassResolver(javaDescriptorResolver); + constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter); + constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder); + constantDescriptorLoader.setStorage(descriptorDeserializersStorage); javaClassFinder.initialize(); @@ -362,8 +358,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly return this.javaDescriptorResolver; } - public DescriptorDeserializers getDescriptorDeserializers() { - return this.descriptorDeserializers; + public DeserializationGlobalContextForJava getDeserializationGlobalContextForJava() { + return this.deserializationGlobalContextForJava; } } 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 ea61a9122f4..21ec18286c0 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 @@ -56,6 +56,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { public static final List DEFAULT_IMPORTS = ImmutableList.of( new ImportPath("java.lang.*"), new ImportPath("kotlin.*"), + new ImportPath("kotlin.jvm.*"), new ImportPath("kotlin.io.*"), new ImportPath("kotlin.reflect.*") ); @@ -153,7 +154,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { module.addFragmentProvider( DependencyKind.SOURCES, new IncrementalPackageFragmentProvider( - files, module, globalContext.getStorageManager(), injector.getDescriptorDeserializers(), + files, module, globalContext.getStorageManager(), injector.getDeserializationGlobalContextForJava(), incrementalCache, moduleId, injector.getJavaDescriptorResolver() ) ); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/PackagePartClassUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/PackagePartClassUtils.java index 4a2b18624f1..5d20f681968 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/PackagePartClassUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/PackagePartClassUtils.java @@ -72,6 +72,6 @@ public class PackagePartClassUtils { @NotNull public static FqName getPackagePartFqName(@NotNull DeserializedCallableMemberDescriptor callable) { FqName packageFqName = ((PackageFragmentDescriptor) callable.getContainingDeclaration()).getFqName(); - return packageFqName.child(BaseDescriptorDeserializer.getPackagePartClassName(callable)); + return packageFqName.child(BaseDescriptorLoader.getPackagePartClassName(callable)); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt index 28497a07128..f52d0c4d651 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt @@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl import org.jetbrains.jet.lang.resolve.scopes.JetScope import org.jetbrains.jet.storage.StorageManager import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope -import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers import org.jetbrains.jet.descriptors.serialization.DescriptorFinder import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver @@ -45,12 +44,13 @@ import org.jetbrains.jet.lang.resolve.kotlin.PackagePartClassUtils import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf import org.jetbrains.jet.lang.resolve.java.JvmClassName import org.jetbrains.jet.descriptors.serialization.PackageData +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava public class IncrementalPackageFragmentProvider( sourceFiles: Collection, val module: ModuleDescriptor, val storageManager: StorageManager, - val deserializers: Deserializers, + val deserializationContext: DeserializationGlobalContextForJava, val incrementalCache: IncrementalCache, val moduleId: String, val javaDescriptorResolver: JavaDescriptorResolver @@ -124,7 +124,7 @@ public class IncrementalPackageFragmentProvider( } private inner class IncrementalPackageScope(val packageData: PackageData) : DeserializedPackageMemberScope( - storageManager, this@IncrementalPackageFragment, deserializers, descriptorFinder, packageData + this@IncrementalPackageFragment, packageData, deserializationContext ) { override fun filteredMemberProtos(allMemberProtos: Collection): Collection { return allMemberProtos diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 2b284bf45a6..0107ecd5373 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -49,10 +49,10 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -93,10 +93,10 @@ public class InjectorForTopDownAnalyzerBasic { private final DeclarationResolver declarationResolver; private final ImportsResolver importsResolver; private final JetImportsFactory jetImportsFactory; - private final ScriptHeaderResolver scriptHeaderResolver; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; public InjectorForTopDownAnalyzerBasic( @NotNull Project project, @@ -137,10 +137,10 @@ public class InjectorForTopDownAnalyzerBasic { this.declarationResolver = new DeclarationResolver(); this.importsResolver = new ImportsResolver(); this.jetImportsFactory = new JetImportsFactory(); - this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); @@ -232,7 +232,6 @@ public class InjectorForTopDownAnalyzerBasic { declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); - declarationResolver.setScriptHeaderResolver(scriptHeaderResolver); declarationResolver.setTrace(bindingTrace); importsResolver.setImportsFactory(jetImportsFactory); @@ -242,9 +241,6 @@ public class InjectorForTopDownAnalyzerBasic { jetImportsFactory.setProject(project); - scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - scriptHeaderResolver.setTrace(bindingTrace); - overloadResolver.setTrace(bindingTrace); overrideResolver.setTrace(bindingTrace); @@ -255,6 +251,9 @@ public class InjectorForTopDownAnalyzerBasic { typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); + } @PreDestroy diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java index 78e1885567b..cac012ab8a3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java @@ -93,7 +93,7 @@ public abstract class JetStubElementType { public open override /*1*/ fun (): kotlin.Int public open override /*1*/ val start: kotlin.Byte public open override /*1*/ fun (): kotlin.Byte + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.ByteIterator } @@ -170,6 +171,7 @@ public final class ByteRange : kotlin.Range, kotlin.Progression(): kotlin.Byte public open override /*1*/ fun contains(/*0*/ item: kotlin.Byte): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.ByteIterator public class object { @@ -259,6 +261,7 @@ public final class CharProgression : kotlin.Progression { public open override /*1*/ fun (): kotlin.Int public open override /*1*/ val start: kotlin.Char public open override /*1*/ fun (): kotlin.Char + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.CharIterator } @@ -288,6 +291,7 @@ public final class CharRange : kotlin.Range, kotlin.Progression(): kotlin.Char public open override /*1*/ fun contains(/*0*/ item: kotlin.Char): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.CharIterator public class object { @@ -404,6 +408,7 @@ public final class DoubleProgression : kotlin.Progression { public open override /*1*/ fun (): kotlin.Double public open override /*1*/ val start: kotlin.Double public open override /*1*/ fun (): kotlin.Double + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.DoubleIterator } @@ -430,6 +435,7 @@ public final class DoubleRange : kotlin.Range, kotlin.Progression public open override /*2*/ val start: kotlin.Double public open override /*2*/ fun (): kotlin.Double public open override /*1*/ fun contains(/*0*/ item: kotlin.Double): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.DoubleIterator public class object { @@ -627,6 +633,7 @@ public final class FloatProgression : kotlin.Progression { public open override /*1*/ fun (): kotlin.Float public open override /*1*/ val start: kotlin.Float public open override /*1*/ fun (): kotlin.Float + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.FloatIterator } @@ -653,6 +660,7 @@ public final class FloatRange : kotlin.Range, kotlin.Progression(): kotlin.Float public open override /*1*/ fun contains(/*0*/ item: kotlin.Float): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.FloatIterator public class object { @@ -887,6 +895,7 @@ public final class IntProgression : kotlin.Progression { public open override /*1*/ fun (): kotlin.Int public open override /*1*/ val start: kotlin.Int public open override /*1*/ fun (): kotlin.Int + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.IntIterator } @@ -916,6 +925,7 @@ public final class IntRange : kotlin.Range, kotlin.Progression(): kotlin.Int public open override /*1*/ fun contains(/*0*/ item: kotlin.Int): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.IntIterator public class object { @@ -1054,6 +1064,7 @@ public final class LongProgression : kotlin.Progression { public open override /*1*/ fun (): kotlin.Long public open override /*1*/ val start: kotlin.Long public open override /*1*/ fun (): kotlin.Long + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.LongIterator } @@ -1083,6 +1094,7 @@ public final class LongRange : kotlin.Range, kotlin.Progression(): kotlin.Long public open override /*1*/ fun contains(/*0*/ item: kotlin.Long): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.LongIterator public class object { @@ -1245,6 +1257,7 @@ public trait Range> { public abstract val start: T public abstract fun (): T public abstract fun contains(/*0*/ item: T): kotlin.Boolean + public open fun isEmpty(): kotlin.Boolean } public trait Set : kotlin.Collection { @@ -1345,6 +1358,7 @@ public final class ShortProgression : kotlin.Progression { public open override /*1*/ fun (): kotlin.Int public open override /*1*/ val start: kotlin.Short public open override /*1*/ fun (): kotlin.Short + public final fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.ShortIterator } @@ -1374,6 +1388,7 @@ public final class ShortRange : kotlin.Range, kotlin.Progression(): kotlin.Short public open override /*1*/ fun contains(/*0*/ item: kotlin.Short): kotlin.Boolean + public open override /*1*/ fun isEmpty(): kotlin.Boolean public open override /*1*/ fun iterator(): kotlin.ShortIterator public class object { diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/jvmFlags.kt b/compiler/testData/codegen/boxWithStdlib/annotations/jvmFlags.kt new file mode 100644 index 00000000000..1d3446a39f6 --- /dev/null +++ b/compiler/testData/codegen/boxWithStdlib/annotations/jvmFlags.kt @@ -0,0 +1,21 @@ +import java.lang.reflect.Modifier + +class C { + volatile var vol = 1 + transient val tra = 1 + + strictfp fun str() {} + synchronized fun sync() {} +} + +fun box(): String { + val c = javaClass() + + if (c.getDeclaredField("vol").getModifiers() and Modifier.VOLATILE == 0) return "Fail: volatile" + if (c.getDeclaredField("tra").getModifiers() and Modifier.TRANSIENT == 0) return "Fail: transient" + + if (c.getDeclaredMethod("str").getModifiers() and Modifier.STRICT == 0) return "Fail: strict" + if (c.getDeclaredMethod("sync").getModifiers() and Modifier.SYNCHRONIZED == 0) return "Fail: synchronized" + + return "OK" +} diff --git a/compiler/testData/codegen/bytecodeText/noFlagAnnotations.kt b/compiler/testData/codegen/bytecodeText/noFlagAnnotations.kt new file mode 100644 index 00000000000..3f143e7bfc1 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/noFlagAnnotations.kt @@ -0,0 +1,10 @@ +volatile var vol = 1 +transient val tra = 1 + +strictfp fun str() {} +synchronized fun sync() {} + +// 0 kotlin/jvm/volatile +// 0 kotlin/jvm/transient +// 0 kotlin/jvm/strictfp +// 0 kotlin/jvm/synchronized diff --git a/compiler/testData/codegen/bytecodeText/noVolatileAnnotation.kt b/compiler/testData/codegen/bytecodeText/noVolatileAnnotation.kt deleted file mode 100644 index 11dc5d3f182..00000000000 --- a/compiler/testData/codegen/bytecodeText/noVolatileAnnotation.kt +++ /dev/null @@ -1,3 +0,0 @@ -volatile val foo: Int = 1 - -// 0 kotlin/volatile diff --git a/compiler/testData/loadJava/compiledJava/PrivateMembers.java b/compiler/testData/loadJava/compiledJava/PrivateMembers.java new file mode 100644 index 00000000000..f02f5d4be6f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PrivateMembers.java @@ -0,0 +1,30 @@ +package test; + +public class PrivateMembers { + private PrivateMembers() { + } + + private int field = 1; + private static int staticField = 2; + + private void method() { + } + + private void samAdapter(SamInterface r) { + } + + private static void staticMethod() { + } + + private class Inner { + } + + private interface SamInterface { + void foo(); + } + + private static class Nested { + private static void staticMethodInNested() { + } + } +} diff --git a/compiler/testData/loadJava/compiledJava/PrivateMembers.txt b/compiler/testData/loadJava/compiledJava/PrivateMembers.txt new file mode 100644 index 00000000000..4463db12d23 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PrivateMembers.txt @@ -0,0 +1,31 @@ +package test + +public open class PrivateMembers : java.lang.Object { + private constructor PrivateMembers() + private final var field: kotlin.Int + private open fun method(): kotlin.Unit + private final /*synthesized*/ fun samAdapter(/*0*/ p0: (() -> kotlin.Unit)?): kotlin.Unit + private open fun samAdapter(/*0*/ p0: test.PrivateMembers.SamInterface?): kotlin.Unit + + private open inner class Inner : java.lang.Object { + private constructor Inner() + } + + private open class Nested : java.lang.Object { + private constructor Nested() + } + + private trait SamInterface : java.lang.Object { + public abstract fun foo(): kotlin.Unit + } +} + +package test.PrivateMembers { + private var staticField: kotlin.Int + private /*synthesized*/ fun SamInterface(/*0*/ function: () -> kotlin.Unit): test.PrivateMembers.SamInterface + private open fun staticMethod(): kotlin.Unit + + package test.PrivateMembers.Nested { + private open fun staticMethodInNested(): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java b/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java new file mode 100644 index 00000000000..c4530580042 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java @@ -0,0 +1,19 @@ +package test; + +public class PrivateMembersInHierarchy { + public static class Super { + private int field = 1; + private int field2 = 1; + + private void method() { + } + } + + public static class Sub extends Super { + private int field = 1; + + private void method() { + } + } +} + diff --git a/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.txt b/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.txt new file mode 100644 index 00000000000..7275997f1a3 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.txt @@ -0,0 +1,19 @@ +package test + +public open class PrivateMembersInHierarchy : java.lang.Object { + public constructor PrivateMembersInHierarchy() + + public open class Sub : test.PrivateMembersInHierarchy.Super { + public constructor Sub() + private final var field: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var field2: kotlin.Int + private open fun method(): kotlin.Unit + } + + public open class Super : java.lang.Object { + public constructor Super() + private final var field: kotlin.Int + private final var field2: kotlin.Int + private open fun method(): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt index 691a30890d3..8aa68a937e6 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt @@ -2,9 +2,12 @@ package test public abstract class ClassDoesNotOverrideMethod : java.util.Date { public constructor ClassDoesNotOverrideMethod() + invisible_fake final override /*1*/ /*fake_override*/ var cdate: sun.util.calendar.BaseCalendar.Date? + invisible_fake final override /*1*/ /*fake_override*/ var fastTime: kotlin.Long public open override /*1*/ /*fake_override*/ fun after(/*0*/ p0: java.util.Date): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun before(/*0*/ p0: java.util.Date): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: java.util.Date): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarDate(): sun.util.calendar.BaseCalendar.Date? kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getDay(): kotlin.Int kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getHours(): kotlin.Int @@ -12,8 +15,12 @@ public abstract class ClassDoesNotOverrideMethod : java.util.Date { kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getMonth(): kotlin.Int kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getSeconds(): kotlin.Int public open override /*1*/ /*fake_override*/ fun getTime(): kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ fun getTimeImpl(): kotlin.Long kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getTimezoneOffset(): kotlin.Int kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getYear(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun normalize(): sun.util.calendar.BaseCalendar.Date? + invisible_fake final override /*1*/ /*fake_override*/ fun normalize(/*0*/ p0: sun.util.calendar.BaseCalendar.Date?): sun.util.calendar.BaseCalendar.Date? + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream?): kotlin.Unit kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0: kotlin.Int): kotlin.Unit kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0: kotlin.Int): kotlin.Unit kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0: kotlin.Int): kotlin.Unit @@ -23,4 +30,5 @@ public abstract class ClassDoesNotOverrideMethod : java.util.Date { kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0: kotlin.Int): kotlin.Unit kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun toGMTString(): kotlin.String kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun toLocaleString(): kotlin.String + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream?): kotlin.Unit } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt index 9463b8db02f..bfa2d292f29 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt @@ -17,6 +17,8 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String? + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit public open override /*1*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun remove(/*0*/ index: kotlin.Int): kotlin.String public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection): kotlin.Boolean diff --git a/compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt b/compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt new file mode 100644 index 00000000000..8a4a19cd3d9 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt @@ -0,0 +1,14 @@ +//ALLOW_AST_ACCESS + +package test + +public class PrivateClassMembers { + private val v = 0 + + private var r = 0 + private set + + private fun f() = 0 + + internal val internal = 0 +} diff --git a/compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.txt b/compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.txt new file mode 100644 index 00000000000..a47d068548b --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.txt @@ -0,0 +1,13 @@ +package test + +public final class PrivateClassMembers { + /*primary*/ public constructor PrivateClassMembers() + internal final val internal: kotlin.Int = 0 + internal final fun (): kotlin.Int + private final var r: kotlin.Int + private final fun (): kotlin.Int + private final fun (/*0*/ : kotlin.Int): kotlin.Unit + private final val v: kotlin.Int = 0 + private final fun (): kotlin.Int + private final fun f(): kotlin.Int +} diff --git a/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt new file mode 100644 index 00000000000..0ff5452763a --- /dev/null +++ b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt @@ -0,0 +1,4 @@ +package test + +public class InheritJavaField(): Super() { +} diff --git a/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.txt b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.txt new file mode 100644 index 00000000000..25d9f3762b8 --- /dev/null +++ b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.txt @@ -0,0 +1,15 @@ +package test + +public final class InheritJavaField : test.Super { + public constructor InheritJavaField() + public final override /*1*/ /*fake_override*/ var field: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var privateField: kotlin.Int + public open override /*1*/ /*fake_override*/ fun method(): kotlin.Int +} + +public open class Super : java.lang.Object { + public constructor Super() + public final var field: kotlin.Int + private final var privateField: kotlin.Int + public open fun method(): kotlin.Int +} diff --git a/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField/Super.java b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField/Super.java new file mode 100644 index 00000000000..a6427c5fdd0 --- /dev/null +++ b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField/Super.java @@ -0,0 +1,7 @@ +package test; + +public class Super { + public int field = 55; + private int privateField = 54; + public int method() { return 1; } +} diff --git a/compiler/testData/mockJDK/jre/lib/rt.jar b/compiler/testData/mockJDK/jre/lib/rt.jar index 612d76c1482..bc09a129fae 100644 Binary files a/compiler/testData/mockJDK/jre/lib/rt.jar and b/compiler/testData/mockJDK/jre/lib/rt.jar differ diff --git a/compiler/testData/mockJDK/src.zip b/compiler/testData/mockJDK/src.zip index 7acc804630b..0a1d6b2634d 100644 Binary files a/compiler/testData/mockJDK/src.zip and b/compiler/testData/mockJDK/src.zip differ diff --git a/compiler/testData/psi/BackslashInString.kt b/compiler/testData/psi/BackslashInString.kt new file mode 100644 index 00000000000..b39bb2c32b5 --- /dev/null +++ b/compiler/testData/psi/BackslashInString.kt @@ -0,0 +1,3 @@ +fun foo() { + "\ +} diff --git a/compiler/testData/psi/BackslashInString.txt b/compiler/testData/psi/BackslashInString.txt new file mode 100644 index 00000000000..b4530baaa1d --- /dev/null +++ b/compiler/testData/psi/BackslashInString.txt @@ -0,0 +1,22 @@ +JetFile: BackslashInString.kt + PACKAGE_DIRECTIVE + + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('foo') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"') + PsiErrorElement:Unexpected token in a string template + PsiElement(BAD_CHARACTER)('\') + PsiErrorElement:Expecting '"' + + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') diff --git a/compiler/tests/org/jetbrains/jet/codegen/BytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/BytecodeTextTestGenerated.java index 5bda0c1b766..269eef9a9de 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/BytecodeTextTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/BytecodeTextTestGenerated.java @@ -122,9 +122,9 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { doTest("compiler/testData/codegen/bytecodeText/kt5016intOrNull.kt"); } - @TestMetadata("noVolatileAnnotation.kt") - public void testNoVolatileAnnotation() throws Exception { - doTest("compiler/testData/codegen/bytecodeText/noVolatileAnnotation.kt"); + @TestMetadata("noFlagAnnotations.kt") + public void testNoFlagAnnotations() throws Exception { + doTest("compiler/testData/codegen/bytecodeText/noFlagAnnotations.kt"); } @TestMetadata("noWrapperForMethodReturningPrimitive.kt") diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java index 3e17574daba..840c767b4fd 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java @@ -48,6 +48,11 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt"); } + @TestMetadata("jvmFlags.kt") + public void testJvmFlags() throws Exception { + doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/annotations/jvmFlags.kt"); + } + @TestMetadata("kotlinPropertyFromClassObjectAsParameter.kt") public void testKotlinPropertyFromClassObjectAsParameter() throws Exception { doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/annotations/kotlinPropertyFromClassObjectAsParameter.kt"); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index ee863c05b7d..4f20fb8b50a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java @@ -64,6 +64,16 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTestCompiledJava("compiler/testData/loadJava/compiledJava/PackageLocalVisibility.java"); } + @TestMetadata("PrivateMembers.java") + public void testPrivateMembers() throws Exception { + doTestCompiledJava("compiler/testData/loadJava/compiledJava/PrivateMembers.java"); + } + + @TestMetadata("PrivateMembersInHierarchy.java") + public void testPrivateMembersInHierarchy() throws Exception { + doTestCompiledJava("compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java"); + } + @TestMetadata("RawTypeWithUpperBound.java") public void testRawTypeWithUpperBound() throws Exception { doTestCompiledJava("compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.java"); @@ -2978,6 +2988,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTestCompiledKotlin("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt"); } + @TestMetadata("PrivateClassMembers.kt") + public void testPrivateClassMembers() throws Exception { + doTestCompiledKotlin("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt"); + } + @TestMetadata("PrivateTopLevelFun.kt") public void testPrivateTopLevelFun() throws Exception { doTestCompiledKotlin("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt"); @@ -3167,6 +3182,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), false); } + @TestMetadata("InheritJavaField.kt") + public void testInheritJavaField() throws Exception { + doTestKotlinAgainstCompiledJavaWithKotlin("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt"); + } + @TestMetadata("InheritParameterName.kt") public void testInheritParameterName() throws Exception { doTestKotlinAgainstCompiledJavaWithKotlin("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritParameterName.kt"); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveRecursiveComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveRecursiveComparingTestGenerated.java index 3196853ceab..9ef982632ec 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveRecursiveComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveRecursiveComparingTestGenerated.java @@ -1456,6 +1456,11 @@ public class LazyResolveRecursiveComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt"); } + @TestMetadata("PrivateClassMembers.kt") + public void testPrivateClassMembers() throws Exception { + doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt"); + } + @TestMetadata("PrivateTopLevelFun.kt") public void testPrivateTopLevelFun() throws Exception { doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt"); diff --git a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTestGenerated.java b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTestGenerated.java index b170b9bcb3c..5354505a960 100644 --- a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTestGenerated.java @@ -84,6 +84,11 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest { doParsingTest("compiler/testData/psi/BabySteps_ERR.kt"); } + @TestMetadata("BackslashInString.kt") + public void testBackslashInString() throws Exception { + doParsingTest("compiler/testData/psi/BackslashInString.kt"); + } + @TestMetadata("BlockCommentAtBeginningOfFile1.kt") public void testBlockCommentAtBeginningOfFile1() throws Exception { doParsingTest("compiler/testData/psi/BlockCommentAtBeginningOfFile1.kt"); diff --git a/core/builtins/src/kotlin/Progressions.kt b/core/builtins/src/kotlin/Progressions.kt index 774dadb1a9e..4d35c7ea78a 100644 --- a/core/builtins/src/kotlin/Progressions.kt +++ b/core/builtins/src/kotlin/Progressions.kt @@ -29,10 +29,14 @@ public class ByteProgression( override fun iterator(): ByteIterator = ByteProgressionIterator(start, end, increment) - override fun equals(other: Any?): Boolean = - other is ByteProgression && start == other.start && end == other.end && increment == other.increment + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end - override fun hashCode(): Int = 31 * (31 * start.toInt() + end) + increment + override fun equals(other: Any?): Boolean = + other is ByteProgression && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end && increment == other.increment) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment) override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}" } @@ -48,10 +52,14 @@ public class CharProgression( override fun iterator(): CharIterator = CharProgressionIterator(start, end, increment) - override fun equals(other: Any?): Boolean = - other is CharProgression && start == other.start && end == other.end && increment == other.increment + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end - override fun hashCode(): Int = 31 * (31 * start.toInt() + end) + increment + override fun equals(other: Any?): Boolean = + other is CharProgression && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end && increment == other.increment) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment) override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}" } @@ -67,10 +75,14 @@ public class ShortProgression( override fun iterator(): ShortIterator = ShortProgressionIterator(start, end, increment) - override fun equals(other: Any?): Boolean = - other is ShortProgression && start == other.start && end == other.end && increment == other.increment + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end - override fun hashCode(): Int = 31 * (31 * start.toInt() + end) + increment + override fun equals(other: Any?): Boolean = + other is ShortProgression && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end && increment == other.increment) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment) override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}" } @@ -86,10 +98,14 @@ public class IntProgression( override fun iterator(): IntIterator = IntProgressionIterator(start, end, increment) - override fun equals(other: Any?): Boolean = - other is IntProgression && start == other.start && end == other.end && increment == other.increment + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end - override fun hashCode(): Int = 31 * (31 * start + end) + increment + override fun equals(other: Any?): Boolean = + other is IntProgression && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end && increment == other.increment) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (31 * start + end) + increment) override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}" } @@ -105,10 +121,14 @@ public class LongProgression( override fun iterator(): LongIterator = LongProgressionIterator(start, end, increment) - override fun equals(other: Any?): Boolean = - other is LongProgression && start == other.start && end == other.end && increment == other.increment + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end - override fun hashCode(): Int = (31 * (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))) + (increment xor (increment ushr 32))).toInt() + override fun equals(other: Any?): Boolean = + other is LongProgression && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end && increment == other.increment) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))) + (increment xor (increment ushr 32))).toInt() override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}" } @@ -125,10 +145,14 @@ public class FloatProgression( override fun iterator(): FloatIterator = FloatProgressionIterator(start, end, increment) - override fun equals(other: Any?): Boolean = - other is FloatProgression && java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0 && java.lang.Float.compare(increment, other.increment) == 0 + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end - override fun hashCode(): Int = 31 * (31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end)) + java.lang.Float.floatToIntBits(increment) + override fun equals(other: Any?): Boolean = + other is FloatProgression && (isEmpty() && other.isEmpty() || + java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0 && java.lang.Float.compare(increment, other.increment) == 0) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end)) + java.lang.Float.floatToIntBits(increment)) override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}" } @@ -145,10 +169,14 @@ public class DoubleProgression( override fun iterator(): DoubleIterator = DoubleProgressionIterator(start, end, increment) + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end + override fun equals(other: Any?): Boolean = - other is DoubleProgression && java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0 && java.lang.Double.compare(increment, other.increment) == 0 + other is DoubleProgression && (isEmpty() && other.isEmpty() || + java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0 && java.lang.Double.compare(increment, other.increment) == 0) override fun hashCode(): Int { + if (isEmpty()) return -1 var temp = java.lang.Double.doubleToLongBits(start) var result = (temp xor (temp ushr 32)) temp = java.lang.Double.doubleToLongBits(end) diff --git a/core/builtins/src/kotlin/Range.kt b/core/builtins/src/kotlin/Range.kt index eae8bbab1d7..b70be49d4e8 100644 --- a/core/builtins/src/kotlin/Range.kt +++ b/core/builtins/src/kotlin/Range.kt @@ -23,5 +23,7 @@ public trait Range> { public fun contains(item: T): Boolean + public fun isEmpty(): Boolean = start > end + override fun toString(): String = "$start..$end" } diff --git a/core/builtins/src/kotlin/Ranges.kt b/core/builtins/src/kotlin/Ranges.kt index ebd9574cc62..eec2e24f6c8 100644 --- a/core/builtins/src/kotlin/Ranges.kt +++ b/core/builtins/src/kotlin/Ranges.kt @@ -26,10 +26,14 @@ public class ByteRange(public override val start: Byte, public override val end: override fun iterator(): ByteIterator = ByteProgressionIterator(start, end, 1) - override fun equals(other: Any?): Boolean = - other is ByteRange && start == other.start && end == other.end + override fun isEmpty(): Boolean = start > end - override fun hashCode(): Int = 31 * start.toInt() + end + override fun equals(other: Any?): Boolean = + other is ByteRange && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * start.toInt() + end) class object { public val EMPTY: ByteRange = ByteRange(1, 0) @@ -44,10 +48,14 @@ public class CharRange(public override val start: Char, public override val end: override fun iterator(): CharIterator = CharProgressionIterator(start, end, 1) - override fun equals(other: Any?): Boolean = - other is CharRange && start == other.start && end == other.end + override fun isEmpty(): Boolean = start > end - override fun hashCode(): Int = 31 * start.toInt() + end + override fun equals(other: Any?): Boolean = + other is CharRange && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * start.toInt() + end) class object { public val EMPTY: CharRange = CharRange(1.toChar(), 0.toChar()) @@ -62,10 +70,14 @@ public class ShortRange(public override val start: Short, public override val en override fun iterator(): ShortIterator = ShortProgressionIterator(start, end, 1) - override fun equals(other: Any?): Boolean = - other is ShortRange && start == other.start && end == other.end + override fun isEmpty(): Boolean = start > end - override fun hashCode(): Int = 31 * start.toInt() + end + override fun equals(other: Any?): Boolean = + other is ShortRange && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * start.toInt() + end) class object { public val EMPTY: ShortRange = ShortRange(1, 0) @@ -80,10 +92,14 @@ public class IntRange(public override val start: Int, public override val end: I override fun iterator(): IntIterator = IntProgressionIterator(start, end, 1) - override fun equals(other: Any?): Boolean = - other is IntRange && start == other.start && end == other.end + override fun isEmpty(): Boolean = start > end - override fun hashCode(): Int = 31 * start + end + override fun equals(other: Any?): Boolean = + other is IntRange && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * start + end) class object { public val EMPTY: IntRange = IntRange(1, 0) @@ -98,10 +114,14 @@ public class LongRange(public override val start: Long, public override val end: override fun iterator(): LongIterator = LongProgressionIterator(start, end, 1) - override fun equals(other: Any?): Boolean = - other is LongRange && start == other.start && end == other.end + override fun isEmpty(): Boolean = start > end - override fun hashCode(): Int = (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))).toInt() + override fun equals(other: Any?): Boolean = + other is LongRange && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * (start xor (start ushr 32)) + (end xor (end ushr 32))).toInt() class object { public val EMPTY: LongRange = LongRange(1, 0) @@ -116,10 +136,14 @@ public class FloatRange(public override val start: Float, public override val en override fun iterator(): FloatIterator = FloatProgressionIterator(start, end, 1.0f) - override fun equals(other: Any?): Boolean = - other is FloatRange && java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0 + override fun isEmpty(): Boolean = start > end - override fun hashCode(): Int = 31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end) + override fun equals(other: Any?): Boolean = + other is FloatRange && (isEmpty() && other.isEmpty() || + java.lang.Float.compare(start, other.start) == 0 && java.lang.Float.compare(end, other.end) == 0) + + override fun hashCode(): Int = + if (isEmpty()) -1 else (31 * java.lang.Float.floatToIntBits(start) + java.lang.Float.floatToIntBits(end)) class object { public val EMPTY: FloatRange = FloatRange(1.0f, 0.0f) @@ -134,10 +158,14 @@ public class DoubleRange(public override val start: Double, public override val override fun iterator(): DoubleIterator = DoubleProgressionIterator(start, end, 1.0) + override fun isEmpty(): Boolean = start > end + override fun equals(other: Any?): Boolean = - other is DoubleRange && java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0 + other is DoubleRange && (isEmpty() && other.isEmpty() || + java.lang.Double.compare(start, other.start) == 0 && java.lang.Double.compare(end, other.end) == 0) override fun hashCode(): Int { + if (isEmpty()) return -1 var temp = java.lang.Double.doubleToLongBits(start) val result = (temp xor (temp ushr 32)) temp = java.lang.Double.doubleToLongBits(end) diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/MemberIndex.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/MemberIndex.kt index c76ce7ab31a..5bcae7e64b2 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/MemberIndex.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/MemberIndex.kt @@ -41,13 +41,7 @@ object EMPTY_MEMBER_INDEX : MemberIndex { override fun getAllFieldNames() = listOf() } -open class ClassMemberIndex(val jClass: JavaClass, filter: (JavaMember) -> Boolean) : MemberIndex { - private val memberFilter = { - (m: JavaMember) -> - filter(m) && - m.getVisibility() != Visibilities.PRIVATE - } - +open class ClassMemberIndex(val jClass: JavaClass, val memberFilter: (JavaMember) -> Boolean) : MemberIndex { private val methodFilter = { (m: JavaMethod) -> memberFilter(m) && diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.java similarity index 97% rename from core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java rename to core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.java index d7d0c547e04..bbdb2d45c07 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.java @@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf; import org.jetbrains.jet.descriptors.serialization.NameResolver; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; -import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl; @@ -46,10 +46,10 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; -public class AnnotationDescriptorDeserializer extends BaseDescriptorDeserializer implements AnnotationDeserializer { +public class AnnotationDescriptorLoader extends BaseDescriptorLoader implements AnnotationLoader { @Inject @Override public void setStorage(@NotNull DescriptorDeserializersStorage storage) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorLoader.java similarity index 98% rename from core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java rename to core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorLoader.java index 2bd12420109..c0f2e5b332e 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorLoader.java @@ -31,14 +31,14 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait; import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName; import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.naiveKotlinFqName; -public abstract class BaseDescriptorDeserializer { +public abstract class BaseDescriptorLoader { protected DependencyClassByQualifiedNameResolver classResolver; protected KotlinClassFinder kotlinClassFinder; protected ErrorReporter errorReporter; diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.java similarity index 92% rename from core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java rename to core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.java index 0f240a14531..22d203ba035 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.java @@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.NameResolver; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; -import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer; +import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader; import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; @@ -28,10 +28,10 @@ import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; import javax.inject.Inject; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; -public class ConstantDescriptorDeserializer extends BaseDescriptorDeserializer implements ConstantDeserializer { +public class ConstantDescriptorLoader extends BaseDescriptorLoader implements ConstantLoader { @Inject @Override public void setStorage(@NotNull DescriptorDeserializersStorage storage) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java deleted file mode 100644 index eec84302c3d..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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.lang.resolve.kotlin; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; -import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer; -import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers; - -import javax.inject.Inject; - -public class DescriptorDeserializers implements Deserializers { - - private AnnotationDescriptorDeserializer annotationDescriptorDeserializer; - private ConstantDescriptorDeserializer constantDescriptorDeserializer; - - @Inject - public void setAnnotationDescriptorDeserializer(AnnotationDescriptorDeserializer annotationDescriptorDeserializer) { - this.annotationDescriptorDeserializer = annotationDescriptorDeserializer; - } - - @Inject - public void setConstantDescriptorDeserializer(ConstantDescriptorDeserializer constantDescriptorDeserializer) { - this.constantDescriptorDeserializer = constantDescriptorDeserializer; - } - - @NotNull - @Override - public AnnotationDeserializer getAnnotationDeserializer() { - return annotationDescriptorDeserializer; - } - - @NotNull - @Override - public ConstantDeserializer getConstantDeserializer() { - return constantDescriptorDeserializer; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java index a0e7c12688a..866c8899d95 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java @@ -108,7 +108,7 @@ public class DescriptorDeserializersStorage { result = new ArrayList(); memberAnnotations.put(paramSignature, result); } - return AnnotationDescriptorDeserializer.resolveAnnotation(className, result, classResolver); + return AnnotationDescriptorLoader.resolveAnnotation(className, result, classResolver); } } @@ -123,7 +123,7 @@ public class DescriptorDeserializersStorage { @Nullable @Override public KotlinJvmBinaryClass.AnnotationArgumentVisitor visitAnnotation(@NotNull JvmClassName className) { - return AnnotationDescriptorDeserializer.resolveAnnotation(className, result, classResolver); + return AnnotationDescriptorLoader.resolveAnnotation(className, result, classResolver); } @Override diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt new file mode 100644 index 00000000000..5e74f50087b --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt @@ -0,0 +1,29 @@ +/* + * 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.lang.resolve.kotlin + +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext +import org.jetbrains.jet.storage.StorageManager +import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider + +public class DeserializationGlobalContextForJava( + storageManager: StorageManager, + descriptorFinder: JavaDescriptorFinder, + annotationLoader: AnnotationDescriptorLoader, + constantLoader: ConstantDescriptorLoader, + packageFragmentProvider: LazyJavaPackageFragmentProvider +) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader, constantLoader, packageFragmentProvider) 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 97ff219b3ec..f35d0f30dcc 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 @@ -19,68 +19,28 @@ package org.jetbrains.jet.lang.resolve.kotlin; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.ClassData; -import org.jetbrains.jet.descriptors.serialization.ClassId; -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.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.storage.StorageManager; import javax.inject.Inject; -import java.util.Collection; -import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName; import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.CLASS; import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.PACKAGE_FACADE; public final class DeserializedDescriptorResolver { - private DescriptorDeserializers deserializers; - - private StorageManager storageManager; - - private JavaPackageFragmentProvider javaPackageFragmentProvider; - - private JavaDescriptorResolver javaDescriptorResolver; + private DeserializationGlobalContextForJava context; private ErrorReporter errorReporter; - @NotNull - private final DescriptorFinder javaDescriptorFinder = new DescriptorFinder() { - @Nullable - @Override - public ClassDescriptor findClass(@NotNull ClassId classId) { - return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName())); - } - - @NotNull - @Override - public Collection getClassNames(@NotNull FqName packageName) { - return javaPackageFragmentProvider.getClassNamesInPackage(packageName); - } - }; - @Inject - public void setDeserializers(DescriptorDeserializers deserializers) { - this.deserializers = deserializers; - } - - @Inject - public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) { - this.javaPackageFragmentProvider = javaPackageFragmentProvider; - } - - @Inject - public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) { - this.javaDescriptorResolver = javaDescriptorResolver; + public void setContext(DeserializationGlobalContextForJava context) { + this.context = context; } @Inject @@ -88,18 +48,12 @@ public final class DeserializedDescriptorResolver { this.errorReporter = errorReporter; } - @Inject - public void setStorageManager(StorageManager storageManager) { - this.storageManager = storageManager; - } - @Nullable public ClassDescriptor resolveClass(@NotNull KotlinJvmBinaryClass kotlinClass) { String[] data = readData(kotlinClass, CLASS); if (data != null) { ClassData classData = JavaProtoBufUtil.readClassDataFrom(data); - return new DeserializedClassDescriptor(storageManager, deserializers, javaDescriptorFinder, - javaPackageFragmentProvider, classData.getNameResolver(), classData.getClassProto()); + return new DeserializedClassDescriptor(context, classData); } return null; } @@ -108,8 +62,7 @@ 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, deserializers, - javaDescriptorFinder, JavaProtoBufUtil.readPackageDataFrom(data)); + return new DeserializedPackageMemberScope(descriptor, JavaProtoBufUtil.readPackageDataFrom(data), context); } return null; } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt new file mode 100644 index 00000000000..43b79efcd45 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt @@ -0,0 +1,41 @@ +/* + * 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.lang.resolve.kotlin + +import org.jetbrains.annotations.Nullable +import org.jetbrains.jet.descriptors.serialization.ClassId +import org.jetbrains.jet.descriptors.serialization.DescriptorFinder +import org.jetbrains.jet.lang.descriptors.ClassDescriptor +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver +import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName + +public class JavaDescriptorFinder( + private val javaDescriptorResolver: DependencyClassByQualifiedNameResolver, + private val javaPackageFragmentProvider: JavaPackageFragmentProvider +) : DescriptorFinder { + + override fun findClass(classId: ClassId): ClassDescriptor? { + return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName())) + } + + override fun getClassNames(packageName: FqName): Collection { + return javaPackageFragmentProvider.getClassNamesInPackage(packageName) + } +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java index 455c7ff4afc..7c29790768c 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java @@ -346,9 +346,10 @@ public class OverridingUtil { @NotNull DescriptorSink sink ) { Collection visibleOverridables = filterVisibleFakeOverrides(current, overridables); - Modality modality = getMinimalModality(visibleOverridables); boolean allInvisible = visibleOverridables.isEmpty(); Collection effectiveOverridden = allInvisible ? overridables : visibleOverridables; + + Modality modality = getMinimalModality(effectiveOverridden); Visibility visibility = allInvisible ? Visibilities.INVISIBLE_FAKE : Visibilities.INHERITED; CallableMemberDescriptor mostSpecific = selectMostSpecificMemberFromSuper(effectiveOverridden); CallableMemberDescriptor fakeOverride = 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 e6a3e2b329e..68800b876ad 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 @@ -20,8 +20,8 @@ import kotlin.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; -import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; -import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; +import org.jetbrains.jet.descriptors.serialization.descriptors.*; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl; @@ -51,9 +51,13 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl { packageFragmentProvider = new BuiltinsPackageFragmentProvider(); - // TODO: support annotations - members = new DeserializedPackageMemberScope(storageManager, this, Deserializers.UNSUPPORTED, - new BuiltInsDescriptorFinder(storageManager), new PackageData(nameResolver, loadPackage())); + DeserializationContext context = new DeserializationContext( + storageManager, new BuiltInsDescriptorFinder(storageManager), + // TODO: support annotations + AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider, + nameResolver + ); + members = new DeserializedPackageMemberScope(this, loadPackage(), context); } @NotNull @@ -118,7 +122,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl { public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) { // TODO: support annotations - super(storageManager, Deserializers.UNSUPPORTED, packageFragmentProvider); + super(storageManager, AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider); classNames = storageManager.createLazyValue(new Function0>() { @Override diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java index 27a2eeb9123..1921bed08c4 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java @@ -19,8 +19,8 @@ package org.jetbrains.jet.descriptors.serialization; import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers; -import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext; +import org.jetbrains.jet.descriptors.serialization.descriptors.*; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; @@ -28,26 +28,21 @@ import org.jetbrains.jet.storage.StorageManager; public abstract class AbstractDescriptorFinder implements DescriptorFinder { private final MemoizedFunctionToNullable findClass; - private final Deserializers deserializers; public AbstractDescriptorFinder( - @NotNull final StorageManager storageManager, - @NotNull Deserializers deserializers, - @NotNull final PackageFragmentProvider packageFragmentProvider + @NotNull StorageManager storageManager, + @NotNull AnnotationLoader annotationLoader, + @NotNull ConstantLoader constantLoader, + @NotNull PackageFragmentProvider packageFragmentProvider ) { - this.deserializers = deserializers; - + final DeserializationGlobalContext deserializationGlobalContext = + new DeserializationGlobalContext(storageManager, this, annotationLoader, constantLoader, + packageFragmentProvider); this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { @Override public ClassDescriptor invoke(ClassId classId) { ClassData classData = getClassData(classId); - if (classData == null) { - return null; - } - - AbstractDescriptorFinder _this = AbstractDescriptorFinder.this; - return new DeserializedClassDescriptor(storageManager, _this.deserializers, _this, packageFragmentProvider, - classData.getNameResolver(), classData.getClassProto()); + return classData == null ? null : new DeserializedClassDescriptor(deserializationGlobalContext, classData); } }); } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/MemberDeserializer.java similarity index 50% rename from core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java rename to core/serialization/src/org/jetbrains/jet/descriptors/serialization/MemberDeserializer.java index c31892c63c9..e0a4c879f93 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/MemberDeserializer.java @@ -19,15 +19,17 @@ package org.jetbrains.jet.descriptors.serialization; import kotlin.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes; import org.jetbrains.jet.descriptors.serialization.descriptors.*; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.descriptors.impl.*; +import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.PropertyGetterDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.PropertySetterDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.DescriptorFactory; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.types.Variance; -import org.jetbrains.jet.storage.StorageManager; import java.util.ArrayList; import java.util.Collections; @@ -35,86 +37,14 @@ import java.util.List; import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable; import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter; -import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*; -public class DescriptorDeserializer { +public class MemberDeserializer { - @NotNull - public static DescriptorDeserializer create( - @NotNull StorageManager storageManager, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NameResolver nameResolver, - @NotNull DescriptorFinder descriptorFinder, - @NotNull Deserializers deserializers - ) { - return new DescriptorDeserializer(storageManager, - new TypeDeserializer(storageManager, null, nameResolver, descriptorFinder, - "Deserializer for " + containingDeclaration.getName(), NONE), - containingDeclaration, nameResolver, deserializers); - } + private final DeserializationContextWithTypes context; - @NotNull - public static DescriptorDeserializer create( - @NotNull StorageManager storageManager, - @NotNull TypeDeserializer typeDeserializer, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NameResolver nameResolver, - @NotNull Deserializers deserializers - ) { - return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, deserializers); - } - - private final DeclarationDescriptor containingDeclaration; - private final NameResolver nameResolver; - private final TypeDeserializer typeDeserializer; - private final Deserializers deserializers; - - private final StorageManager storageManager; - - private DescriptorDeserializer( - @NotNull StorageManager storageManager, - @NotNull TypeDeserializer typeDeserializer, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NameResolver nameResolver, - @NotNull Deserializers deserializers - ) { - this.storageManager = storageManager; - this.typeDeserializer = typeDeserializer; - this.containingDeclaration = containingDeclaration; - this.nameResolver = nameResolver; - this.deserializers = deserializers; - } - - @NotNull - public TypeDeserializer getTypeDeserializer() { - return typeDeserializer; - } - - @NotNull - public NameResolver getNameResolver() { - return nameResolver; - } - - @NotNull - public DescriptorDeserializer createChildDeserializer( - @NotNull DeclarationDescriptor descriptor, - @NotNull final List typeParameterProtos, - @NotNull final List typeParameters - ) { - TypeDeserializer childTypeDeserializer = new TypeDeserializer( - storageManager, - typeDeserializer, "Child deserializer for " + descriptor.getName(), - new TypeDeserializer.TypeParameterResolver() { - @NotNull - @Override - public List getTypeParameters(@NotNull TypeDeserializer typeDeserializer) { - List descriptors = typeParameters(typeParameterProtos, typeDeserializer); - typeParameters.addAll(descriptors); - return descriptors; - } - }); - return create(storageManager, childTypeDeserializer, descriptor, nameResolver, deserializers); + public MemberDeserializer(@NotNull DeserializationContextWithTypes context) { + this.context = context; } @NotNull @@ -137,25 +67,25 @@ public class DescriptorDeserializer { final int flags = proto.getFlags(); DeserializedPropertyDescriptor property = new DeserializedPropertyDescriptor( - containingDeclaration, + context.getContainingDeclaration(), null, getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY), modality(Flags.MODALITY.get(flags)), visibility(Flags.VISIBILITY.get(flags)), Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR, - nameResolver.getName(proto.getName()), - memberKind(Flags.MEMBER_KIND.get(flags)), + context.getNameResolver().getName(proto.getName()), + SerializationPackage.memberKind(Flags.MEMBER_KIND.get(flags)), proto, - nameResolver + context.getNameResolver() ); List typeParameters = new ArrayList(proto.getTypeParameterCount()); - DescriptorDeserializer local = createChildDeserializer(property, proto.getTypeParameterList(), typeParameters); + DeserializationContextWithTypes local = context.childContext(property, proto.getTypeParameterList(), typeParameters); property.setType( - local.typeDeserializer.type(proto.getReturnType()), + local.getTypeDeserializer().type(proto.getReturnType()), typeParameters, getExpectedThisObject(), - local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null) + local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null) ); PropertyGetterDescriptorImpl getter = null; @@ -168,7 +98,8 @@ public class DescriptorDeserializer { getter = new PropertyGetterDescriptorImpl(property, getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER), modality(Flags.MODALITY.get(getterFlags)), - visibility(Flags.VISIBILITY.get(getterFlags)), isNotDefault, !isNotDefault, + visibility(Flags.VISIBILITY.get(getterFlags)), + isNotDefault, !isNotDefault, property.getKind(), null); } else { @@ -184,11 +115,13 @@ public class DescriptorDeserializer { setter = new PropertySetterDescriptorImpl(property, getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER), modality(Flags.MODALITY.get(setterFlags)), - visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, !isNotDefault, + visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, + !isNotDefault, property.getKind(), null); - DescriptorDeserializer setterLocal = local.createChildDeserializer(setter, Collections.emptyList(), - Collections.emptyList()); - List valueParameters = setterLocal.valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER); + DeserializationContextWithTypes setterLocal = local.childContext(setter, Collections.emptyList(), + Collections.emptyList()); + List valueParameters + = setterLocal.getDeserializer().valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER); assert valueParameters.size() == 1 : "Property setter should have a single value parameter: " + setter; setter.initialize(valueParameters.get(0)); } @@ -199,16 +132,16 @@ public class DescriptorDeserializer { if (Flags.HAS_CONSTANT.get(flags)) { property.setCompileTimeInitializer( - storageManager.createNullableLazyValue(new Function0>() { + context.getStorageManager().createNullableLazyValue(new Function0>() { @Nullable @Override public CompileTimeConstant invoke() { + DeclarationDescriptor containingDeclaration = context.getContainingDeclaration(); assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor : "Only members in classes or package fragments should be serialized: " + containingDeclaration; - return deserializers.getConstantDeserializer().loadPropertyConstant( - (ClassOrPackageFragmentDescriptor) containingDeclaration, - proto, nameResolver, - AnnotatedCallableKind.PROPERTY); + return context.getConstantLoader().loadPropertyConstant( + (ClassOrPackageFragmentDescriptor) containingDeclaration, proto, + context.getNameResolver(), AnnotatedCallableKind.PROPERTY); } }) ); @@ -223,18 +156,16 @@ public class DescriptorDeserializer { private CallableMemberDescriptor loadFunction(@NotNull Callable proto) { int flags = proto.getFlags(); DeserializedSimpleFunctionDescriptor function = DeserializedSimpleFunctionDescriptor.create( - containingDeclaration, proto, - deserializers, - nameResolver + context.getContainingDeclaration(), proto, context.getAnnotationLoader(), context.getNameResolver() ); List typeParameters = new ArrayList(proto.getTypeParameterCount()); - DescriptorDeserializer local = createChildDeserializer(function, proto.getTypeParameterList(), typeParameters); + DeserializationContextWithTypes local = context.childContext(function, proto.getTypeParameterList(), typeParameters); function.initialize( - local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null), + local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null), getExpectedThisObject(), typeParameters, - local.valueParameters(proto, AnnotatedCallableKind.FUNCTION), - local.typeDeserializer.type(proto.getReturnType()), + local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION), + local.getTypeDeserializer().type(proto.getReturnType()), modality(Flags.MODALITY.get(flags)), visibility(Flags.VISIBILITY.get(flags)) ); @@ -243,33 +174,34 @@ public class DescriptorDeserializer { @Nullable private ReceiverParameterDescriptor getExpectedThisObject() { + DeclarationDescriptor containingDeclaration = context.getContainingDeclaration(); return containingDeclaration instanceof ClassDescriptor ? ((ClassDescriptor) containingDeclaration).getThisAsReceiverParameter() : null; } @NotNull private CallableMemberDescriptor loadConstructor(@NotNull Callable proto) { - ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; + ClassDescriptor classDescriptor = (ClassDescriptor) context.getContainingDeclaration(); ConstructorDescriptorImpl descriptor = ConstructorDescriptorImpl.create( classDescriptor, getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION), // TODO: primary true); List typeParameters = new ArrayList(proto.getTypeParameterCount()); - DescriptorDeserializer local = createChildDeserializer(descriptor, Collections.emptyList(), typeParameters); + DeserializationContextWithTypes local = context.childContext(descriptor, Collections.emptyList(), typeParameters); descriptor.initialize( classDescriptor.getTypeConstructor().getParameters(), - local.valueParameters(proto, AnnotatedCallableKind.FUNCTION), + local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION), visibility(Flags.VISIBILITY.get(proto.getFlags())), DescriptorUtils.isConstructorOfStaticNestedClass(descriptor) ); - descriptor.setReturnType(local.typeDeserializer.type(proto.getReturnType())); + descriptor.setReturnType(local.getTypeDeserializer().type(proto.getReturnType())); return descriptor; } @NotNull private Annotations getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) { - return getAnnotations(containingDeclaration, proto, flags, kind, deserializers.getAnnotationDeserializer(), nameResolver); + return getAnnotations(context.getContainingDeclaration(), proto, flags, kind, context.getAnnotationLoader(), context.getNameResolver()); } public static Annotations getAnnotations( @@ -277,80 +209,13 @@ public class DescriptorDeserializer { @NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind, - @NotNull AnnotationDeserializer annotationDeserializer, + @NotNull AnnotationLoader annotationLoader, @NotNull NameResolver nameResolver ) { assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor : "Only members in classes or package fragments should be serialized: " + containingDeclaration; - return Flags.HAS_ANNOTATIONS.get(flags) - ? annotationDeserializer - .loadCallableAnnotations((ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind) - : Annotations.EMPTY; - } - - public static CallableMemberDescriptor.Kind memberKind(Callable.MemberKind memberKind) { - switch (memberKind) { - case DECLARATION: - return CallableMemberDescriptor.Kind.DECLARATION; - case FAKE_OVERRIDE: - return CallableMemberDescriptor.Kind.FAKE_OVERRIDE; - case DELEGATION: - return CallableMemberDescriptor.Kind.DELEGATION; - case SYNTHESIZED: - return CallableMemberDescriptor.Kind.SYNTHESIZED; - } - throw new IllegalArgumentException("Unknown member kind: " + memberKind); - } - - @NotNull - public static Modality modality(@NotNull ProtoBuf.Modality modality) { - switch (modality) { - case FINAL: - return Modality.FINAL; - case OPEN: - return Modality.OPEN; - case ABSTRACT: - return Modality.ABSTRACT; - } - throw new IllegalArgumentException("Unknown modality: " + modality); - } - - @NotNull - public static Visibility visibility(@NotNull ProtoBuf.Visibility visibility) { - switch (visibility) { - case INTERNAL: - return Visibilities.INTERNAL; - case PRIVATE: - return Visibilities.PRIVATE; - case PROTECTED: - return Visibilities.PROTECTED; - case PUBLIC: - return Visibilities.PUBLIC; - case EXTRA: - throw new UnsupportedOperationException("Extra visibilities are not supported yet"); // TODO - } - throw new IllegalArgumentException("Unknown visibility: " + visibility); - } - - @NotNull - public static ClassKind classKind(@NotNull ProtoBuf.Class.Kind kind) { - switch (kind) { - case CLASS: - return ClassKind.CLASS; - case TRAIT: - return ClassKind.TRAIT; - case ENUM_CLASS: - return ClassKind.ENUM_CLASS; - case ENUM_ENTRY: - return ClassKind.ENUM_ENTRY; - case ANNOTATION_CLASS: - return ClassKind.ANNOTATION_CLASS; - case OBJECT: - return ClassKind.OBJECT; - case CLASS_OBJECT: - return ClassKind.CLASS_OBJECT; - } - throw new IllegalArgumentException("Unknown class kind: " + kind); + return Flags.HAS_ANNOTATIONS.get(flags) ? annotationLoader.loadCallableAnnotations( + (ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind) : Annotations.EMPTY; } @NotNull @@ -362,11 +227,11 @@ public class DescriptorDeserializer { for (int i = 0; i < protos.size(); i++) { TypeParameter proto = protos.get(i); DeserializedTypeParameterDescriptor descriptor = new DeserializedTypeParameterDescriptor( - storageManager, + context.getStorageManager(), typeDeserializer, proto, - containingDeclaration, - nameResolver.getName(proto.getName()), + context.getContainingDeclaration(), + context.getNameResolver().getName(proto.getName()), variance(proto.getVariance()), proto.getReified(), i @@ -376,21 +241,9 @@ public class DescriptorDeserializer { return result; } - private static Variance variance(TypeParameter.Variance proto) { - switch (proto) { - case IN: - return Variance.IN_VARIANCE; - case OUT: - return Variance.OUT_VARIANCE; - case INV: - return Variance.INVARIANT; - } - throw new IllegalStateException("Unknown projection: " + proto); - } - @NotNull private List valueParameters(@NotNull Callable callable, @NotNull AnnotatedCallableKind kind) { - DeclarationDescriptor containerOfCallable = containingDeclaration.getContainingDeclaration(); + DeclarationDescriptor containerOfCallable = context.getContainingDeclaration().getContainingDeclaration(); assert containerOfCallable instanceof ClassOrPackageFragmentDescriptor : "Only members in classes or package fragments should be serialized: " + containerOfCallable; ClassOrPackageFragmentDescriptor classOrPackage = (ClassOrPackageFragmentDescriptor) containerOfCallable; @@ -400,14 +253,14 @@ public class DescriptorDeserializer { for (int i = 0; i < protos.size(); i++) { Callable.ValueParameter proto = protos.get(i); result.add(new ValueParameterDescriptorImpl( - containingDeclaration, + context.getContainingDeclaration(), null, i, getAnnotations(classOrPackage, callable, kind, proto), - nameResolver.getName(proto.getName()), - typeDeserializer.type(proto.getType()), + context.getNameResolver().getName(proto.getName()), + context.getTypeDeserializer().type(proto.getType()), Flags.DECLARES_DEFAULT_VALUE.get(proto.getFlags()), - typeDeserializer.typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null)) + context.getTypeDeserializer().typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null)) ); } return result; @@ -420,8 +273,8 @@ public class DescriptorDeserializer { @NotNull AnnotatedCallableKind kind, @NotNull Callable.ValueParameter valueParameter ) { - return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) - ? deserializers.getAnnotationDeserializer().loadValueParameterAnnotations(classOrPackage, callable, nameResolver, kind, valueParameter) + return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) ? context.getAnnotationLoader() + .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter) : Annotations.EMPTY; } } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java index 20dc60e8bd9..7fce8635c68 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java @@ -21,6 +21,8 @@ import kotlin.Function0; import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.ReadOnly; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; @@ -30,12 +32,13 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.variance; + public class TypeDeserializer { public interface TypeParameterResolver { @@ -48,11 +51,10 @@ public class TypeDeserializer { }; @NotNull + @ReadOnly List getTypeParameters(@NotNull TypeDeserializer typeDeserializer); } - private final NameResolver nameResolver; - private final DescriptorFinder descriptorFinder; private final TypeDeserializer parent; // never written to after constructor returns @@ -62,45 +64,29 @@ public class TypeDeserializer { private final String debugName; - private final StorageManager storageManager; + private final DeserializationContext context; public TypeDeserializer( - @NotNull StorageManager storageManager, - @NotNull TypeDeserializer parent, - @NotNull String debugName, - @NotNull TypeParameterResolver typeParameterResolver - ) { - this(storageManager, parent, parent.nameResolver, parent.descriptorFinder, debugName, typeParameterResolver); - } - - public TypeDeserializer( - @NotNull StorageManager storageManager, + @NotNull DeserializationContext context, @Nullable TypeDeserializer parent, - @NotNull NameResolver nameResolver, - @NotNull DescriptorFinder descriptorFinder, @NotNull String debugName, @NotNull TypeParameterResolver typeParameterResolver ) { - this.storageManager = storageManager; this.parent = parent; - this.nameResolver = nameResolver; - this.descriptorFinder = descriptorFinder; this.debugName = debugName + (parent == null ? "" : ". Child of " + parent.debugName); + this.context = context; for (DeserializedTypeParameterDescriptor typeParameterDescriptor : typeParameterResolver.getTypeParameters(this)) { typeParameterDescriptors.put(typeParameterDescriptor.getProtoId(), typeParameterDescriptor); } - this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { - @Override - public ClassDescriptor invoke(Integer fqNameIndex) { - return computeClassDescriptor(fqNameIndex); - } - }); - } - - /* package */ DescriptorFinder getDescriptorFinder() { - return descriptorFinder; + this.classDescriptors = context.getStorageManager().createMemoizedFunctionWithNullableValues( + new Function1() { + @Override + public ClassDescriptor invoke(Integer fqNameIndex) { + return computeClassDescriptor(fqNameIndex); + } + }); } @Nullable @@ -122,7 +108,7 @@ public class TypeDeserializer { TypeConstructor typeConstructor = typeConstructor(constructorProto); if (typeConstructor == null) { String message = constructorProto.getKind() == ProtoBuf.Type.Constructor.Kind.CLASS - ? nameResolver.getClassId(id).asSingleFqName().asString() + ? context.getNameResolver().getClassId(id).asSingleFqName().asString() : "Unknown type parameter " + id; typeConstructor = ErrorUtils.createErrorType(message).getConstructor(); } @@ -159,8 +145,8 @@ public class TypeDeserializer { @Nullable private ClassDescriptor computeClassDescriptor(int fqNameIndex) { - ClassId classId = nameResolver.getClassId(fqNameIndex); - return descriptorFinder.findClass(classId); + ClassId classId = context.getNameResolver().getClassId(fqNameIndex); + return context.getDescriptorFinder().findClass(classId); } private List typeArguments(List protos) { @@ -172,22 +158,7 @@ public class TypeDeserializer { } private TypeProjection typeProjection(ProtoBuf.Type.Argument proto) { - return new TypeProjectionImpl( - variance(proto.getProjection()), - type(proto.getType()) - ); - } - - private static Variance variance(ProtoBuf.Type.Argument.Projection proto) { - switch (proto) { - case IN: - return Variance.IN_VARIANCE; - case OUT: - return Variance.OUT_VARIANCE; - case INV: - return Variance.INVARIANT; - } - throw new IllegalStateException("Unknown projection: " + proto); + return new TypeProjectionImpl(variance(proto.getProjection()), type(proto.getType())); } @NotNull @@ -215,13 +186,13 @@ public class TypeDeserializer { this.typeProto = proto; this.arguments = typeArguments(proto.getArgumentList()); - this.constructor = storageManager.createLazyValue(new Function0() { + this.constructor = context.getStorageManager().createLazyValue(new Function0() { @Override public TypeConstructor invoke() { return typeConstructor(typeProto); } }); - this.memberScope = storageManager.createLazyValue(new Function0() { + this.memberScope = context.getStorageManager().createLazyValue(new Function0() { @Override public JetScope invoke() { return computeMemberScope(); diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt new file mode 100644 index 00000000000..5ad04c4f5cf --- /dev/null +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt @@ -0,0 +1,101 @@ +/* + * 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.context + +import org.jetbrains.jet.storage.StorageManager +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider +import org.jetbrains.jet.descriptors.serialization.DescriptorFinder +import org.jetbrains.jet.descriptors.serialization.NameResolver +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import org.jetbrains.jet.descriptors.serialization.TypeDeserializer +import org.jetbrains.jet.descriptors.serialization.MemberDeserializer +import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor +import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor +import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader + +public open class DeserializationGlobalContext( + public val storageManager: StorageManager, + public val descriptorFinder: DescriptorFinder, + public val annotationLoader: AnnotationLoader, + public val constantLoader: ConstantLoader, + public val packageFragmentProvider: PackageFragmentProvider +) { + public fun withNameResolver(nameResolver: NameResolver): DeserializationContext { + return DeserializationContext(storageManager, descriptorFinder, annotationLoader, + constantLoader, packageFragmentProvider, nameResolver) + } +} + + +public open class DeserializationContext( + storageManager: StorageManager, + descriptorFinder: DescriptorFinder, + annotationLoader: AnnotationLoader, + constantLoader: ConstantLoader, + packageFragmentProvider: PackageFragmentProvider, + public val nameResolver: NameResolver +) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader, + constantLoader, packageFragmentProvider) { + fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes { + val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}", + TypeDeserializer.TypeParameterResolver.NONE) + return withTypes(containingDeclaration, typeDeserializer) + } + + fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes { + return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationLoader, + constantLoader, packageFragmentProvider, + nameResolver, containingDeclaration, + typeDeserializer) + } + +} + + +class DeserializationContextWithTypes( + storageManager: StorageManager, + descriptorFinder: DescriptorFinder, + annotationLoader: AnnotationLoader, + constantLoader: ConstantLoader, + packageFragmentProvider: PackageFragmentProvider, + nameResolver: NameResolver, + val containingDeclaration: DeclarationDescriptor, + val typeDeserializer: TypeDeserializer +) : DeserializationContext(storageManager, descriptorFinder, annotationLoader, + constantLoader, packageFragmentProvider, nameResolver) { + val deserializer: MemberDeserializer = MemberDeserializer(this) + + public fun childContext( + descriptor: DeclarationDescriptor, + typeParameterProtos: List, + typeParameters: MutableList + ): DeserializationContextWithTypes { + val childTypeParameterResolver = object : TypeDeserializer.TypeParameterResolver { + override fun getTypeParameters(typeDeserializer: TypeDeserializer): List { + val descriptors = deserializer.typeParameters(typeParameterProtos, typeDeserializer) + typeParameters.addAll(descriptors) + return descriptors + } + } + val childTypeDeserializer = TypeDeserializer(this, typeDeserializer, "Child deserializer for " + descriptor.getName(), + childTypeParameterResolver) + return withTypes(descriptor, childTypeDeserializer) + } + +} diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java new file mode 100644 index 00000000000..87858ff474a --- /dev/null +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java @@ -0,0 +1,24 @@ +/* + * 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; + +public enum AnnotatedCallableKind { + FUNCTION, + PROPERTY, + PROPERTY_GETTER, + PROPERTY_SETTER +} diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationLoader.java similarity index 93% rename from core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java rename to core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationLoader.java index 0186a81646e..6ca965b151f 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationLoader.java @@ -23,10 +23,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; - -public interface AnnotationDeserializer { - AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() { +public interface AnnotationLoader { + AnnotationLoader UNSUPPORTED = new AnnotationLoader() { @NotNull @Override public Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) { diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantLoader.java similarity index 88% rename from core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java rename to core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantLoader.java index 96b3c8b668c..02d8f84baec 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantLoader.java @@ -23,10 +23,8 @@ import org.jetbrains.jet.descriptors.serialization.ProtoBuf; import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; - -public interface ConstantDeserializer { - ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() { +public interface ConstantLoader { + ConstantLoader UNSUPPORTED = new ConstantLoader() { @Nullable @Override public CompileTimeConstant loadPropertyConstant( diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java index cf3eeb56ccb..a8542e1e41a 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java @@ -22,6 +22,9 @@ import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; import org.jetbrains.jet.lang.descriptors.impl.AbstractClassDescriptor; @@ -45,21 +48,17 @@ import org.jetbrains.jet.storage.StorageManager; import java.util.*; -import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE; +import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*; import static org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName; public class DeserializedClassDescriptor extends AbstractClassDescriptor implements ClassDescriptor { private final ClassId classId; private final ProtoBuf.Class classProto; - private final StorageManager storageManager; - private final TypeDeserializer typeDeserializer; - private final DescriptorDeserializer deserializer; private final DeserializedMemberScope memberScope; private final NullableLazyValue primaryConstructor; - private final Deserializers deserializers; private final NotNullLazyValue annotations; private final NullableLazyValue classObjectDescriptor; @@ -72,33 +71,22 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme private final Visibility visibility; private final ClassKind kind; private final boolean isInner; - private final DescriptorFinder descriptorFinder; - private final PackageFragmentProvider packageFragmentProvider; + private final DeserializationContextWithTypes context; - public DeserializedClassDescriptor( - @NotNull StorageManager storageManager, - @NotNull Deserializers deserializers, - @NotNull DescriptorFinder descriptorFinder, - @NotNull PackageFragmentProvider packageFragmentProvider, - @NotNull NameResolver nameResolver, - @NotNull ProtoBuf.Class classProto - ) { - super(storageManager, nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName()); + public DeserializedClassDescriptor(@NotNull DeserializationGlobalContext globalContext, @NotNull ClassData classData) { + this(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto()); + } + + public DeserializedClassDescriptor(@NotNull DeserializationContext outerContext, @NotNull ProtoBuf.Class classProto) { + super(outerContext.getStorageManager(), + outerContext.getNameResolver().getClassId(classProto.getFqName()).getRelativeClassName().shortName()); this.classProto = classProto; - this.classId = nameResolver.getClassId(classProto.getFqName()); - this.storageManager = storageManager; - this.packageFragmentProvider = packageFragmentProvider; - this.descriptorFinder = descriptorFinder; + this.classId = outerContext.getNameResolver().getClassId(classProto.getFqName()); - TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(storageManager, null, nameResolver, - descriptorFinder, "Deserializer for class " + getName(), NONE); - DescriptorDeserializer outerDeserializer = DescriptorDeserializer.create(storageManager, notNullTypeDeserializer, - this, nameResolver, deserializers); List typeParameters = new ArrayList(classProto.getTypeParameterCount()); - this.deserializer = outerDeserializer.createChildDeserializer(this, classProto.getTypeParameterList(), typeParameters); - this.typeDeserializer = deserializer.getTypeDeserializer(); + this.context = outerContext.withTypes(this).childContext(this, classProto.getTypeParameterList(), typeParameters); - this.containingDeclaration = storageManager.createLazyValue(new Function0() { + this.containingDeclaration = outerContext.getStorageManager().createLazyValue(new Function0() { @Override public DeclarationDescriptor invoke() { return computeContainingDeclaration(); @@ -106,30 +94,29 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme }); this.typeConstructor = new DeserializedClassTypeConstructor(typeParameters); - this.memberScope = new DeserializedClassMemberScope(storageManager, this); + this.memberScope = new DeserializedClassMemberScope(); int flags = classProto.getFlags(); - this.modality = DescriptorDeserializer.modality(Flags.MODALITY.get(flags)); - this.visibility = DescriptorDeserializer.visibility(Flags.VISIBILITY.get(flags)); - this.kind = DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(flags)); + this.modality = modality(Flags.MODALITY.get(flags)); + this.visibility = visibility(Flags.VISIBILITY.get(flags)); + this.kind = classKind(Flags.CLASS_KIND.get(flags)); this.isInner = Flags.INNER.get(flags); - this.deserializers = deserializers; - this.annotations = storageManager.createLazyValue(new Function0() { + this.annotations = context.getStorageManager().createLazyValue(new Function0() { @Override public Annotations invoke() { return computeAnnotations(); } }); - this.primaryConstructor = storageManager.createNullableLazyValue(new Function0() { + this.primaryConstructor = context.getStorageManager().createNullableLazyValue(new Function0() { @Override public ConstructorDescriptor invoke() { return computePrimaryConstructor(); } }); - this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0() { + this.classObjectDescriptor = context.getStorageManager().createNullableLazyValue(new Function0() { @Override public ClassDescriptor invoke() { return computeClassObjectDescriptor(); @@ -148,12 +135,13 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme @NotNull private DeclarationDescriptor computeContainingDeclaration() { if (classId.isTopLevelClass()) { - List fragments = packageFragmentProvider.getPackageFragments(classId.getPackageFqName()); + List fragments = + context.getPackageFragmentProvider().getPackageFragments(classId.getPackageFqName()); assert fragments.size() == 1 : "there should be exactly one package: " + fragments; return fragments.iterator().next(); } else { - ClassOrPackageFragmentDescriptor result = descriptorFinder.findClass(classId.getOuterClassId()); + ClassDescriptor result = context.getDescriptorFinder().findClass(classId.getOuterClassId()); return result != null ? result : ErrorUtils.getErrorModule(); } } @@ -192,7 +180,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) { return Annotations.EMPTY; } - return deserializers.getAnnotationDeserializer().loadClassAnnotations(this, classProto); + return context.getAnnotationLoader().loadClassAnnotations(this, classProto); } @NotNull @@ -218,7 +206,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme return descriptor; } - return (ConstructorDescriptor) deserializer.loadCallable(constructorProto.getData()); + return (ConstructorDescriptor) context.getDeserializer().loadCallable(constructorProto.getData()); } @Nullable @@ -254,11 +242,10 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme throw new IllegalStateException("Object should have a serialized class object: " + classId); } - return new DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider, - deserializer.getNameResolver(), classObjectProto.getData()); + return new DeserializedClassDescriptor(context, classObjectProto.getData()); } - return descriptorFinder.findClass(classId.createNestedClassId(getClassObjectName(getName()))); + return context.getDescriptorFinder().findClass(classId.createNestedClassId(getClassObjectName(getName()))); } @NotNull @@ -313,7 +300,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme private Collection computeSuperTypes() { List supertypes = new ArrayList(classProto.getSupertypeCount()); for (ProtoBuf.Type supertype : classProto.getSupertypeList()) { - supertypes.add(typeDeserializer.type(supertype)); + supertypes.add(context.getTypeDeserializer().type(supertype)); } return supertypes; } @@ -384,12 +371,12 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme } } - private static class DeserializedClassMemberScope extends DeserializedMemberScope { + private class DeserializedClassMemberScope extends DeserializedMemberScope { private final DeserializedClassDescriptor classDescriptor; - public DeserializedClassMemberScope(@NotNull StorageManager storageManager, @NotNull DeserializedClassDescriptor classDescriptor) { - super(storageManager, classDescriptor, classDescriptor.deserializer, classDescriptor.classProto.getMemberList()); - this.classDescriptor = classDescriptor; + public DeserializedClassMemberScope() { + super(context, DeserializedClassDescriptor.this.classProto.getMemberList()); + this.classDescriptor = DeserializedClassDescriptor.this; } @Override @@ -485,6 +472,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme this.nestedClassNames = nestedClassNames(); this.enumEntryNames = enumEntryNames(); + final StorageManager storageManager = context.getStorageManager(); final NotNullLazyValue> enumMemberNames = storageManager.createLazyValue(new Function0>() { @Override public Collection invoke() { @@ -500,7 +488,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme .create(storageManager, DeserializedClassDescriptor.this, name, enumMemberNames); } if (nestedClassNames.contains(name)) { - return descriptorFinder.findClass(classId.createNestedClassId(name)); + return context.getDescriptorFinder().findClass(classId.createNestedClassId(name)); } return null; } @@ -510,7 +498,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme @NotNull private Set nestedClassNames() { Set result = new HashSet(); - NameResolver nameResolver = deserializer.getNameResolver(); + NameResolver nameResolver = context.getNameResolver(); for (Integer index : classProto.getNestedClassNameList()) { result.add(nameResolver.getName(index)); } @@ -524,7 +512,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme } Set result = new HashSet(); - NameResolver nameResolver = deserializer.getNameResolver(); + NameResolver nameResolver = context.getNameResolver(); for (Integer index : classProto.getEnumEntryList()) { result.add(nameResolver.getName(index)); } @@ -543,7 +531,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme } } - final NameResolver nameResolver = deserializer.getNameResolver(); + final NameResolver nameResolver = context.getNameResolver(); return KotlinPackage.mapTo(classProto.getMemberList(), result, new Function1() { @Override public Name invoke(@NotNull ProtoBuf.Callable callable) { diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java index 035de4cc5f5..81026e5b420 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java @@ -21,9 +21,9 @@ import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; -import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer; import org.jetbrains.jet.descriptors.serialization.Flags; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -50,24 +50,20 @@ public abstract class DeserializedMemberScope implements JetScope { } }; - private final DeclarationDescriptor containingDeclaration; - private final DescriptorDeserializer deserializer; - private final NotNullLazyValue>> membersProtos; private final MemoizedFunctionToNotNull> functions; private final MemoizedFunctionToNotNull> properties; private final NotNullLazyValue> allDescriptors; + private final DeserializationContextWithTypes context; protected DeserializedMemberScope( - @NotNull StorageManager storageManager, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull DescriptorDeserializer deserializer, + @NotNull DeserializationContextWithTypes context, @NotNull final Collection membersList ) { - this.containingDeclaration = containingDeclaration; - this.deserializer = deserializer; + this.context = context; + StorageManager storageManager = context.getStorageManager(); this.membersProtos = storageManager.createLazyValue(new Function0>>() { @Override public Map> invoke() { @@ -80,18 +76,22 @@ public abstract class DeserializedMemberScope implements JetScope { return computeFunctions(name); } }); - this.properties = storageManager.createMemoizedFunction(new Function1>() { - @Override - public Collection invoke(Name name) { - return computeProperties(name); - } - }); - this.allDescriptors = storageManager.createLazyValue(new Function0>() { - @Override - public Collection invoke() { - return computeAllDescriptors(); - } - }); + this.properties = storageManager.createMemoizedFunction( + new Function1>() { + @Override + public Collection invoke(Name name) { + return computeProperties(name); + } + } + ); + this.allDescriptors = storageManager.createLazyValue( + new Function0>() { + @Override + public Collection invoke() { + return computeAllDescriptors(); + } + } + ); } @NotNull @@ -104,7 +104,7 @@ public abstract class DeserializedMemberScope implements JetScope { private Map> groupByName(@NotNull Collection membersList) { Map> map = new HashMap>(); for (ProtoBuf.Callable memberProto : membersList) { - Name name = deserializer.getNameResolver().getName(memberProto.getName()); + Name name = context.getNameResolver().getName(memberProto.getName()); List protos = map.get(name); if (protos == null) { protos = new ArrayList(1); @@ -124,7 +124,7 @@ public abstract class DeserializedMemberScope implements JetScope { for (ProtoBuf.Callable memberProto : memberProtos) { if (callableKind.accept(Flags.CALLABLE_KIND.get(memberProto.getFlags()))) { //noinspection unchecked - descriptors.add((D) deserializer.loadCallable(memberProto)); + descriptors.add((D) context.getDeserializer().loadCallable(memberProto)); } } } @@ -190,7 +190,7 @@ public abstract class DeserializedMemberScope implements JetScope { @NotNull @Override public DeclarationDescriptor getContainingDeclaration() { - return containingDeclaration; + return context.getContainingDeclaration(); } @NotNull @@ -250,7 +250,7 @@ public abstract class DeserializedMemberScope implements JetScope { p.println(getClass().getSimpleName(), " {"); p.pushIndent(); - p.println("containingDeclaration = " + containingDeclaration); + p.println("containingDeclaration = " + getContainingDeclaration()); p.popIndent(); p.println("}"); diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java index 76a65f495f7..a4569fdacfc 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java @@ -18,7 +18,11 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.*; +import org.jetbrains.jet.descriptors.serialization.ClassId; +import org.jetbrains.jet.descriptors.serialization.PackageData; +import org.jetbrains.jet.descriptors.serialization.ProtoBuf; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; @@ -26,40 +30,40 @@ import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.storage.StorageManager; -import java.util.ArrayList; import java.util.Collection; -import java.util.List; public class DeserializedPackageMemberScope extends DeserializedMemberScope { - private final DescriptorFinder descriptorFinder; private final FqName packageFqName; + private final DeserializationContext context; public DeserializedPackageMemberScope( - @NotNull StorageManager storageManager, @NotNull PackageFragmentDescriptor packageDescriptor, - @NotNull Deserializers deserializers, - @NotNull DescriptorFinder descriptorFinder, - @NotNull PackageData packageData + @NotNull ProtoBuf.Package proto, + @NotNull DeserializationContext context ) { - super(storageManager, packageDescriptor, - DescriptorDeserializer.create(storageManager, packageDescriptor, packageData.getNameResolver(), descriptorFinder, deserializers), - packageData.getPackageProto().getMemberList()); - this.descriptorFinder = descriptorFinder; + super(context.withTypes(packageDescriptor), proto.getMemberList()); + this.context = context; this.packageFqName = packageDescriptor.getFqName(); } + public DeserializedPackageMemberScope( + @NotNull PackageFragmentDescriptor packageDescriptor, + @NotNull PackageData packageData, + @NotNull DeserializationGlobalContext context + ) { + this(packageDescriptor, packageData.getPackageProto(), context.withNameResolver(packageData.getNameResolver())); + } @Nullable @Override protected ClassDescriptor getClassDescriptor(@NotNull Name name) { - return descriptorFinder.findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name))); + return context.getDescriptorFinder().findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name))); } @Override protected void addAllClassDescriptors(@NotNull Collection result) { - for (Name className : descriptorFinder.getClassNames(packageFqName)) { + for (Name className : context.getDescriptorFinder().getClassNames(packageFqName)) { ClassDescriptor classDescriptor = getClassDescriptor(className); if (classDescriptor != null) { diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java index 28722f0acf3..604c301c7bd 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java @@ -18,10 +18,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer; -import org.jetbrains.jet.descriptors.serialization.Flags; -import org.jetbrains.jet.descriptors.serialization.NameResolver; -import org.jetbrains.jet.descriptors.serialization.ProtoBuf; +import org.jetbrains.jet.descriptors.serialization.*; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; @@ -87,19 +84,19 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript public static DeserializedSimpleFunctionDescriptor create( @NotNull DeclarationDescriptor containingDeclaration, @NotNull ProtoBuf.Callable proto, - @NotNull Deserializers deserializers, + @NotNull AnnotationLoader annotationLoader, @NotNull NameResolver nameResolver ) { - Annotations annotations = DescriptorDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(), - Deserializers.AnnotatedCallableKind.FUNCTION, - deserializers.getAnnotationDeserializer(), - nameResolver); + Annotations annotations = MemberDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(), + AnnotatedCallableKind.FUNCTION, + annotationLoader, + nameResolver); return new DeserializedSimpleFunctionDescriptor( containingDeclaration, null, annotations, nameResolver.getName(proto.getName()), - DescriptorDeserializer.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())), + SerializationPackage.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())), proto, nameResolver); } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java deleted file mode 100644 index 7e3b534cc62..00000000000 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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.annotations.NotNull; - -public interface Deserializers { - Deserializers UNSUPPORTED = new Deserializers() { - @NotNull - @Override - public AnnotationDeserializer getAnnotationDeserializer() { - return AnnotationDeserializer.UNSUPPORTED; - } - - @NotNull - @Override - public ConstantDeserializer getConstantDeserializer() { - return ConstantDeserializer.UNSUPPORTED; - } - }; - - @NotNull - AnnotationDeserializer getAnnotationDeserializer(); - - @NotNull - ConstantDeserializer getConstantDeserializer(); - - enum AnnotatedCallableKind { - FUNCTION, - PROPERTY, - PROPERTY_GETTER, - PROPERTY_SETTER - } -} diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt new file mode 100644 index 00000000000..513f9b73173 --- /dev/null +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt @@ -0,0 +1,68 @@ +/* + * 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 + +import org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor +import org.jetbrains.jet.lang.descriptors.Modality +import org.jetbrains.jet.lang.descriptors.Visibilities +import org.jetbrains.jet.lang.descriptors.ClassKind +import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter +import org.jetbrains.jet.lang.types.Variance + +fun memberKind(memberKind: Callable.MemberKind) = when (memberKind) { + ProtoBuf.Callable.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION + ProtoBuf.Callable.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE + ProtoBuf.Callable.MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION + ProtoBuf.Callable.MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED +} + +fun modality(modality: ProtoBuf.Modality) = when (modality) { + ProtoBuf.Modality.FINAL -> Modality.FINAL + ProtoBuf.Modality.OPEN -> Modality.OPEN + ProtoBuf.Modality.ABSTRACT -> Modality.ABSTRACT +} + +fun visibility(visibility: ProtoBuf.Visibility) = when (visibility) { + ProtoBuf.Visibility.INTERNAL -> Visibilities.INTERNAL + ProtoBuf.Visibility.PRIVATE -> Visibilities.PRIVATE + ProtoBuf.Visibility.PROTECTED -> Visibilities.PROTECTED + ProtoBuf.Visibility.PUBLIC -> Visibilities.PUBLIC + ProtoBuf.Visibility.EXTRA -> throw UnsupportedOperationException("Extra visibilities are not supported yet") +} + +public fun classKind(kind: ProtoBuf.Class.Kind): ClassKind = when (kind) { + ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS + ProtoBuf.Class.Kind.TRAIT -> ClassKind.TRAIT + ProtoBuf.Class.Kind.ENUM_CLASS -> ClassKind.ENUM_CLASS + ProtoBuf.Class.Kind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY + ProtoBuf.Class.Kind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS + ProtoBuf.Class.Kind.OBJECT -> ClassKind.OBJECT + ProtoBuf.Class.Kind.CLASS_OBJECT -> ClassKind.CLASS_OBJECT +} + +fun variance(variance: TypeParameter.Variance) = when (variance) { + ProtoBuf.TypeParameter.Variance.IN -> Variance.IN_VARIANCE + ProtoBuf.TypeParameter.Variance.OUT -> Variance.OUT_VARIANCE + ProtoBuf.TypeParameter.Variance.INV -> Variance.INVARIANT +} + +fun variance(variance: ProtoBuf.Type.Argument.Projection) = when (variance) { + ProtoBuf.Type.Argument.Projection.IN -> Variance.IN_VARIANCE + ProtoBuf.Type.Argument.Projection.OUT -> Variance.OUT_VARIANCE + ProtoBuf.Type.Argument.Projection.INV -> Variance.INVARIANT +} diff --git a/generators/src/org/jetbrains/jet/generators/builtins/progressions.kt b/generators/src/org/jetbrains/jet/generators/builtins/progressions.kt index 9f5d9648fb0..c55d4d7ce4a 100644 --- a/generators/src/org/jetbrains/jet/generators/builtins/progressions.kt +++ b/generators/src/org/jetbrains/jet/generators/builtins/progressions.kt @@ -45,11 +45,16 @@ class GenerateProgressions(out: PrintWriter) : BuiltInsSourceGenerator(out) { val constructor = checkNaN + checkZero val hashCode = when (kind) { - BYTE, CHAR, SHORT -> "= 31 * (31 * start.toInt() + end) + increment" - INT -> "= 31 * (31 * start + end) + increment" - LONG -> "= (31 * (31 * ${hashLong("start")} + ${hashLong("end")}) + ${hashLong("increment")}).toInt()" - FLOAT -> "= 31 * (31 * ${floatToIntBits("start")} + ${floatToIntBits("end")}) + ${floatToIntBits("increment")}" + BYTE, CHAR, SHORT -> "=\n" + + " if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)" + INT -> "=\n" + + " if (isEmpty()) -1 else (31 * (31 * start + end) + increment)" + LONG -> "=\n" + + " if (isEmpty()) -1 else (31 * (31 * ${hashLong("start")} + ${hashLong("end")}) + ${hashLong("increment")}).toInt()" + FLOAT -> "=\n" + + " if (isEmpty()) -1 else (31 * (31 * ${floatToIntBits("start")} + ${floatToIntBits("end")}) + ${floatToIntBits("increment")})" DOUBLE -> "{\n" + + " if (isEmpty()) return -1\n" + " var temp = ${doubleToLongBits("start")}\n" + " var result = ${hashLong("temp")}\n" + " temp = ${doubleToLongBits("end")}\n" + @@ -71,8 +76,11 @@ class GenerateProgressions(out: PrintWriter) : BuiltInsSourceGenerator(out) { override fun iterator(): ${t}Iterator = ${t}ProgressionIterator(start, end, increment) + public fun isEmpty(): Boolean = if (increment > 0) start > end else start < end + override fun equals(other: Any?): Boolean = - other is $progression && ${compare("start")} && ${compare("end")} && ${compare("increment")} + other is $progression && (isEmpty() && other.isEmpty() || + ${compare("start")} && ${compare("end")} && ${compare("increment")}) override fun hashCode(): Int $hashCode diff --git a/generators/src/org/jetbrains/jet/generators/builtins/ranges.kt b/generators/src/org/jetbrains/jet/generators/builtins/ranges.kt index 6ed53a96fde..e7d92a05ed3 100644 --- a/generators/src/org/jetbrains/jet/generators/builtins/ranges.kt +++ b/generators/src/org/jetbrains/jet/generators/builtins/ranges.kt @@ -45,11 +45,16 @@ class GenerateRanges(out: PrintWriter) : BuiltInsSourceGenerator(out) { fun compare(v: String) = areEqualNumbers(kind, v) val hashCode = when (kind) { - BYTE, CHAR, SHORT -> "= 31 * start.toInt() + end" - INT -> "= 31 * start + end" - LONG -> "= (31 * ${hashLong("start")} + ${hashLong("end")}).toInt()" - FLOAT -> "= 31 * ${floatToIntBits("start")} + ${floatToIntBits("end")}" + BYTE, CHAR, SHORT -> "=\n" + + " if (isEmpty()) -1 else (31 * start.toInt() + end)" + INT -> "=\n" + + " if (isEmpty()) -1 else (31 * start + end)" + LONG -> "=\n" + + " if (isEmpty()) -1 else (31 * ${hashLong("start")} + ${hashLong("end")}).toInt()" + FLOAT -> "=\n" + + " if (isEmpty()) -1 else (31 * ${floatToIntBits("start")} + ${floatToIntBits("end")})" DOUBLE -> "{\n" + + " if (isEmpty()) return -1\n" + " var temp = ${doubleToLongBits("start")}\n" + " val result = ${hashLong("temp")}\n" + " temp = ${doubleToLongBits("end")}\n" + @@ -66,8 +71,11 @@ class GenerateRanges(out: PrintWriter) : BuiltInsSourceGenerator(out) { override fun iterator(): ${t}Iterator = ${t}ProgressionIterator(start, end, $increment) + override fun isEmpty(): Boolean = start > end + override fun equals(other: Any?): Boolean = - other is $range && ${compare("start")} && ${compare("end")} + other is $range && (isEmpty() && other.isEmpty() || + ${compare("start")} && ${compare("end")}) override fun hashCode(): Int $hashCode diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 51e5dcd53c3..490a8c28e08 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils import org.jetbrains.jet.lang.resolve.calls.CallResolver import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -98,7 +98,7 @@ private fun generatorForTopDownAnalyzerForJvm() = commonForTopDownAnalyzer() publicField(javaClass()) - publicField(javaClass()) + publicField(javaClass()) fields( javaClass(), diff --git a/generators/src/org/jetbrains/jet/generators/mockJDK/GenerateMockJdk.java b/generators/src/org/jetbrains/jet/generators/mockJDK/GenerateMockJdk.java index 33b5be36cc4..3785c324462 100644 --- a/generators/src/org/jetbrains/jet/generators/mockJDK/GenerateMockJdk.java +++ b/generators/src/org/jetbrains/jet/generators/mockJDK/GenerateMockJdk.java @@ -270,6 +270,7 @@ public class GenerateMockJdk { "javax/swing/SwingConstants.class", "javax/swing/SwingUtilities.class", "javax/swing/table/TableModel.class", + "sun/util/calendar/BaseCalendar.class", "META-INF/", "META-INF/MANIFEST.MF", }; diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java b/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java index d23d4a2a49f..849003409bd 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java @@ -90,7 +90,7 @@ public class JetFromJavaDescriptorHelper { public static ClassKind getCompiledClassKind(@NotNull PsiClass psiClass) { ClassData classData = getClassData(psiClass); if (classData == null) return null; - return DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags())); + return SerializationPackage.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags())); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt index 12435a8b69b..0883e676f8c 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt @@ -33,17 +33,17 @@ import com.intellij.openapi.vfs.VirtualFile import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope -import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer +import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter import org.jetbrains.jet.lang.types.error.MissingDependencyErrorClassDescriptor import org.jetbrains.jet.lang.resolve.java.PackageClassUtils import com.intellij.openapi.diagnostic.Logger import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder 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.lang.resolve.kotlin.ConstantDescriptorLoader import org.jetbrains.jet.lang.resolve.java.structure.JavaClass +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler { val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile) @@ -67,11 +67,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di return Collections.emptyList() } val membersScope = DeserializedPackageMemberScope( - storageManager, createDummyPackageFragment(packageFqName), - deserializers, - descriptorFinder, - JavaProtoBufUtil.readPackageDataFrom(annotationData) + JavaProtoBufUtil.readPackageDataFrom(annotationData), + deserializationContext ) return membersScope.getAllDescriptors() } @@ -108,32 +106,26 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di deserializerStorage.setErrorReporter(LOGGING_REPORTER) } - private val annotationDeserializer = AnnotationDescriptorDeserializer(); + private val annotationLoader = AnnotationDescriptorLoader(); { - annotationDeserializer.setClassResolver { + annotationLoader.setClassResolver { fqName -> classes(fqName.toClassId()) } - annotationDeserializer.setKotlinClassFinder(localClassFinder) - annotationDeserializer.setErrorReporter(LOGGING_REPORTER) - annotationDeserializer.setStorage(deserializerStorage) + annotationLoader.setKotlinClassFinder(localClassFinder) + annotationLoader.setErrorReporter(LOGGING_REPORTER) + annotationLoader.setStorage(deserializerStorage) } - private val constantDeserializer = ConstantDescriptorDeserializer(); + private val constantLoader = ConstantDescriptorLoader(); { - constantDeserializer.setClassResolver { + constantLoader.setClassResolver { fqName -> classes(fqName.toClassId()) } - constantDeserializer.setKotlinClassFinder(localClassFinder) - constantDeserializer.setErrorReporter(LOGGING_REPORTER) - constantDeserializer.setStorage(deserializerStorage) - } - - private val deserializers = DescriptorDeserializers(); - { - deserializers.setAnnotationDescriptorDeserializer(annotationDeserializer) - deserializers.setConstantDescriptorDeserializer(constantDeserializer) + constantLoader.setKotlinClassFinder(localClassFinder) + constantLoader.setErrorReporter(LOGGING_REPORTER) + constantLoader.setStorage(deserializerStorage) } private val descriptorFinder = object : DescriptorFinder { @@ -156,6 +148,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di } } + val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader, + constantLoader, packageFragmentProvider) + private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor { return MutablePackageFragmentDescriptor(ErrorUtils.getErrorModule(), fqName) } @@ -182,8 +177,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di LOG.error("Annotation data missing for ${kotlinClass.getClassName()}") } val classData = JavaProtoBufUtil.readClassDataFrom(data!!) - return DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider, - classData.getNameResolver(), classData.getClassProto()) + return DeserializedClassDescriptor(deserializationContext, classData) } // we need a "magic" way to obtain ClassId from FqName diff --git a/idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java index 596665556ea..83ae5f63739 100644 --- a/idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/stubs/LazyResolveByStubTestGenerated.java @@ -1456,6 +1456,11 @@ public class LazyResolveByStubTestGenerated extends AbstractLazyResolveByStubTes doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt"); } + @TestMetadata("PrivateClassMembers.kt") + public void testPrivateClassMembers() throws Exception { + doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt"); + } + @TestMetadata("PrivateTopLevelFun.kt") public void testPrivateTopLevelFun() throws Exception { doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt"); diff --git a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java index 7fbfdd5568a..6cc93502cf7 100644 --- a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java +++ b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.jps.build; -import com.intellij.openapi.application.PathManager; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.containers.ContainerUtil; @@ -101,9 +100,7 @@ public class KotlinBuilderModuleScriptGenerator { if (noSources) return null; - String scriptFilename = context.getProjectDescriptor().dataManager.getDataPaths().getDataStorageRoot().getName() - + "#" + StringUtil.sanitizeJavaIdentifier(chunk.getName()); - File scriptFile = new File(PathManager.getTempPath() + File.separator + scriptFilename + ".script." + FACTORY.getFileExtension()); + File scriptFile = File.createTempFile("kjps", StringUtil.sanitizeJavaIdentifier(chunk.getName()) + ".script.xml"); writeScriptToFile(context, builder.asText(), scriptFile); diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java b/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java index ecc090ab29a..a6f3f105edf 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java @@ -190,4 +190,8 @@ public final class MiscTest extends AbstractExpressionTest { public void testStringInterpolationEvaluationOrder() throws Exception { fooBoxTest(); } + + public void testKt5058() throws Exception { + checkFooBoxIsTrue("KT-5058.kt"); + } } diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/PatternMatchingTest.java b/js/js.tests/test/org/jetbrains/k2js/test/semantics/PatternMatchingTest.java index bc76c3d1bf0..755dce1002d 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/semantics/PatternMatchingTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/semantics/PatternMatchingTest.java @@ -89,4 +89,20 @@ public final class PatternMatchingTest extends SingleFileTranslationTest { public void testIfInWhen() throws Exception { checkFooBoxIsOk(); } + + public void testForWithOneStmWhen() throws Exception { + fooBoxTest(); + } + + public void testWhileWithOneStmWhen() throws Exception { + fooBoxTest(); + } + + public void testDoWhileWithOneStmWhen() throws Exception { + fooBoxTest(); + } + + public void testIfWithOneStmWhen() throws Exception { + fooBoxTest(); + } } \ No newline at end of file diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 5e2bdf82900..8c38049e212 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -49,10 +49,10 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -93,10 +93,10 @@ public class InjectorForTopDownAnalyzerForJs { private final DeclarationResolver declarationResolver; private final ImportsResolver importsResolver; private final JetImportsFactory jetImportsFactory; - private final ScriptHeaderResolver scriptHeaderResolver; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; private final TypeHierarchyResolver typeHierarchyResolver; + private final ScriptHeaderResolver scriptHeaderResolver; public InjectorForTopDownAnalyzerForJs( @NotNull Project project, @@ -137,10 +137,10 @@ public class InjectorForTopDownAnalyzerForJs { this.declarationResolver = new DeclarationResolver(); this.importsResolver = new ImportsResolver(); this.jetImportsFactory = new JetImportsFactory(); - this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptHeaderResolver = new ScriptHeaderResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); @@ -232,7 +232,6 @@ public class InjectorForTopDownAnalyzerForJs { declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setDescriptorResolver(descriptorResolver); declarationResolver.setImportsResolver(importsResolver); - declarationResolver.setScriptHeaderResolver(scriptHeaderResolver); declarationResolver.setTrace(bindingTrace); importsResolver.setImportsFactory(jetImportsFactory); @@ -242,9 +241,6 @@ public class InjectorForTopDownAnalyzerForJs { jetImportsFactory.setProject(project); - scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - scriptHeaderResolver.setTrace(bindingTrace); - overloadResolver.setTrace(bindingTrace); overrideResolver.setTrace(bindingTrace); @@ -255,6 +251,9 @@ public class InjectorForTopDownAnalyzerForJs { typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); + scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); + scriptHeaderResolver.setTrace(bindingTrace); + } @PreDestroy diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/expression/WhenTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/expression/WhenTranslator.java index 31fccce0a60..bd8ce45cdbc 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/expression/WhenTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/expression/WhenTranslator.java @@ -40,8 +40,9 @@ public final class WhenTranslator extends AbstractTranslator { WhenTranslator translator = new WhenTranslator(expression, context); if (BindingUtils.isStatement(context.bindingContext(), expression)) { - translator.translateAsStatement(context.dynamicContext().jsBlock().getStatements()); - return null; + JsBlock jsBlock = new JsBlock(); + translator.translateAsStatement(jsBlock.getStatements()); + return jsBlock; } return translator.translateAsExpression(); diff --git a/js/js.translator/testData/expression/misc/cases/KT-5058.kt b/js/js.translator/testData/expression/misc/cases/KT-5058.kt new file mode 100644 index 00000000000..f4280804cad --- /dev/null +++ b/js/js.translator/testData/expression/misc/cases/KT-5058.kt @@ -0,0 +1,25 @@ +package foo + +fun test():Any { + val a: Any = "OK" + val f: Any = + if (true) { + when { + false -> "1" + ((a as? String)?.size ?: 0 > 0) -> a + else -> "2" + } + } + else { + "3" + + } + + return f +} + +fun box(): Boolean { + var result = test() + return result == "OK"; +} + diff --git a/js/js.translator/testData/kotlin_lib.js b/js/js.translator/testData/kotlin_lib.js index 2b1965341df..39e358bd7df 100644 --- a/js/js.translator/testData/kotlin_lib.js +++ b/js/js.translator/testData/kotlin_lib.js @@ -543,6 +543,9 @@ }, iterator: function () { return new Kotlin.RangeIterator(this.start, this.end, this.increment); + }, + isEmpty: function () { + return this.start > this.end; } }); @@ -554,6 +557,9 @@ }, { iterator: function () { return new Kotlin.RangeIterator(this.start, this.end, this.increment); + }, + isEmpty: function() { + return this.increment > 0 ? this.start > this.end : this.start < this.end; } }); diff --git a/js/js.translator/testData/patternMatching/cases/doWhileWithOneStmWhen.kt b/js/js.translator/testData/patternMatching/cases/doWhileWithOneStmWhen.kt new file mode 100644 index 00000000000..aa9b0e9c8c6 --- /dev/null +++ b/js/js.translator/testData/patternMatching/cases/doWhileWithOneStmWhen.kt @@ -0,0 +1,15 @@ +package foo + + +fun box(): Boolean { + var result = false + var i = 1 + do + when (i) { + 1 -> result = true + else -> result = false + } + while (i==0) + return result; +} + diff --git a/js/js.translator/testData/patternMatching/cases/forWithOneStmWhen.kt b/js/js.translator/testData/patternMatching/cases/forWithOneStmWhen.kt new file mode 100644 index 00000000000..a9adca6a303 --- /dev/null +++ b/js/js.translator/testData/patternMatching/cases/forWithOneStmWhen.kt @@ -0,0 +1,13 @@ +package foo + + +fun box(): Boolean { + var result = false + for (i in array(1)) + when (i) { + 1 -> result = true + else -> result = false + } + return result; +} + diff --git a/js/js.translator/testData/patternMatching/cases/ifWithOneStmWhen.kt b/js/js.translator/testData/patternMatching/cases/ifWithOneStmWhen.kt new file mode 100644 index 00000000000..b5786a6edda --- /dev/null +++ b/js/js.translator/testData/patternMatching/cases/ifWithOneStmWhen.kt @@ -0,0 +1,13 @@ +package foo + + +fun box(): Boolean { + var result = false + var i = 1 + if (i==1) + when (i) { + 1 -> result = true + else -> result = false + } + return result; +} diff --git a/js/js.translator/testData/patternMatching/cases/whileWithOneStmWhen.kt b/js/js.translator/testData/patternMatching/cases/whileWithOneStmWhen.kt new file mode 100644 index 00000000000..81e9f4e8315 --- /dev/null +++ b/js/js.translator/testData/patternMatching/cases/whileWithOneStmWhen.kt @@ -0,0 +1,14 @@ +package foo + + +fun box(): Boolean { + var result = false + var i = 1 + while(i==1) + when (i) { + 1 -> { result = true; break } + else -> result = false + } + return result; +} + diff --git a/libraries/stdlib/src/kotlin/JLangJVM.kt b/libraries/stdlib/src/kotlin/JLangJVM.kt index 4f60e0edb2e..64a12e62433 100644 --- a/libraries/stdlib/src/kotlin/JLangJVM.kt +++ b/libraries/stdlib/src/kotlin/JLangJVM.kt @@ -24,9 +24,6 @@ public annotation class throws(vararg val exceptionClasses: Class [Intrinsic("kotlin.javaClass.function")] fun javaClass() : Class = null as Class -Retention(RetentionPolicy.SOURCE) -public annotation class volatile - [Intrinsic("kotlin.synchronized")] public fun synchronized(lock: Any, block: () -> R): R = block() public fun T.annotationType() : Class = diff --git a/libraries/stdlib/src/kotlin/Ranges.kt b/libraries/stdlib/src/kotlin/Ranges.kt index 16cee9b9884..d4a4c46d860 100644 --- a/libraries/stdlib/src/kotlin/Ranges.kt +++ b/libraries/stdlib/src/kotlin/Ranges.kt @@ -1,12 +1,21 @@ package kotlin -public data class ComparableRange> ( +public class ComparableRange> ( public override val start: T, public override val end: T ): Range { - public override fun contains(item: T): Boolean { + override fun contains(item: T): Boolean { return start <= item && item <= end } + + override fun equals(other: Any?): Boolean { + return other is ComparableRange<*> && (isEmpty() && other.isEmpty() || + start == other.start && end == other.end) + } + + override fun hashCode(): Int { + return if (isEmpty()) -1 else 31 * start.hashCode() + end.hashCode() + } } public fun > T.rangeTo(that: T): ComparableRange { diff --git a/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt b/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt new file mode 100644 index 00000000000..18ff6a72b40 --- /dev/null +++ b/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt @@ -0,0 +1,33 @@ +/* + * 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 kotlin.jvm + +import java.lang.annotation.Retention +import java.lang.annotation.RetentionPolicy + +Retention(RetentionPolicy.SOURCE) +public annotation class volatile + +Retention(RetentionPolicy.SOURCE) +public annotation class transient + +Retention(RetentionPolicy.SOURCE) +public annotation class strictfp + +Retention(RetentionPolicy.SOURCE) +public annotation class synchronized + diff --git a/libraries/stdlib/src/kotlin/text/Strings.kt b/libraries/stdlib/src/kotlin/text/Strings.kt index 3aa6067ce77..57c44f98542 100644 --- a/libraries/stdlib/src/kotlin/text/Strings.kt +++ b/libraries/stdlib/src/kotlin/text/Strings.kt @@ -50,8 +50,8 @@ public val CharSequence.size: Int public val String.size: Int get() = length() -public val String.indices : IntRange - get() = 0..size +public val String.indices: IntRange + get() = 0..length() - 1 /** * Returns a subsequence specified by given set of indices. @@ -94,4 +94,4 @@ public fun Array.join(separator: String = ", ", prefix: String = "", pos */ public fun Stream.join(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String { return joinToString(separator, prefix, postfix, limit, truncated) -} \ No newline at end of file +} diff --git a/libraries/stdlib/test/language/RangeTest.kt b/libraries/stdlib/test/language/RangeTest.kt index 52e3bf666a1..20e7672b80c 100644 --- a/libraries/stdlib/test/language/RangeTest.kt +++ b/libraries/stdlib/test/language/RangeTest.kt @@ -18,6 +18,8 @@ public class RangeTest { assertFalse(10 in range) assertFalse(9000 in range) + + assertFalse(range.isEmpty()) } test fun byteRange() { @@ -34,6 +36,8 @@ public class RangeTest { assertFalse(10.toByte() in range) assertFalse(111.toByte() in range) + + assertFalse(range.isEmpty()) } test fun shortRange() { @@ -50,22 +54,26 @@ public class RangeTest { assertFalse(10.toShort() in range) assertFalse(239.toShort() in range) + + assertFalse(range.isEmpty()) } test fun longRange() { - val range = -5.toLong()..9.toLong() - assertFalse(-10000000.toLong() in range) - assertFalse(-6.toLong() in range) + val range = -5L..9L + assertFalse(-10000000L in range) + assertFalse(-6L in range) - assertTrue(-5.toLong() in range) - assertTrue(-4.toLong() in range) - assertTrue(0.toLong() in range) - assertTrue(3.toLong() in range) - assertTrue(8.toLong() in range) - assertTrue(9.toLong() in range) + assertTrue(-5L in range) + assertTrue(-4L in range) + assertTrue(0L in range) + assertTrue(3L in range) + assertTrue(8L in range) + assertTrue(9L in range) - assertFalse(10.toLong() in range) - assertFalse(10000000.toLong() in range) + assertFalse(10L in range) + assertFalse(10000000L in range) + + assertFalse(range.isEmpty()) } test fun charRange() { @@ -82,6 +90,8 @@ public class RangeTest { assertFalse('z' in range) assertFalse('\u1000' in range) + + assertFalse(range.isEmpty()) } test fun doubleRange() { @@ -100,24 +110,94 @@ public class RangeTest { assertFalse(3.15 in range) assertFalse(10.0 in range) assertFalse(1e200 in range) + + assertFalse(range.isEmpty()) } test fun floatRange() { - val range = -1.0.toFloat()..3.14159.toFloat() - assertFalse(-1e30.toFloat() in range) - assertFalse(-100.0.toFloat() in range) - assertFalse(-1.00001.toFloat() in range) + val range = -1.0f..3.14159f + assertFalse(-1e30f in range) + assertFalse(-100.0f in range) + assertFalse(-1.00001f in range) - assertTrue(-1.0.toFloat() in range) - assertTrue(-0.99999.toFloat() in range) - assertTrue(0.0.toFloat() in range) - assertTrue(1.5.toFloat() in range) - assertTrue(3.1415.toFloat() in range) - assertTrue(3.14159.toFloat() in range) + assertTrue(-1.0f in range) + assertTrue(-0.99999f in range) + assertTrue(0.0f in range) + assertTrue(1.5f in range) + assertTrue(3.1415f in range) + assertTrue(3.14159f in range) - assertFalse(3.15.toFloat() in range) - assertFalse(10.0.toFloat() in range) - assertFalse(1e30.toFloat() in range) + assertFalse(3.15f in range) + assertFalse(10.0f in range) + assertFalse(1e30f in range) + + assertFalse(range.isEmpty()) + } + + test fun isEmpty() { + assertTrue((2..1).isEmpty()) + assertTrue((2L..0L).isEmpty()) + assertTrue((1.toShort()..-1.toShort()).isEmpty()) + assertTrue((0.toByte()..-1.toByte()).isEmpty()) + assertTrue((0f..-3.14f).isEmpty()) + assertTrue((-2.72..-3.14).isEmpty()) + assertTrue(('z'..'x').isEmpty()) + + assertTrue((1 downTo 2).isEmpty()) + assertTrue((0L downTo 2L).isEmpty()) + assertFalse((2 downTo 1).isEmpty()) + assertFalse((2L downTo 0L).isEmpty()) + assertTrue(('a' downTo 'z').isEmpty()) + assertTrue(('z'..'a' step 2).isEmpty()) + + assertTrue(("range".."progression").isEmpty()) + } + + test fun emptyEquals() { + assertTrue(IntRange.EMPTY == IntRange.EMPTY) + assertEquals(IntRange.EMPTY, IntRange.EMPTY) + assertEquals(0L..42L, 0L..42L) + assertEquals(3 downTo 0, 3 downTo 0) + + assertEquals(2..1, 1..0) + assertEquals(2L..1L, 1L..0L) + assertEquals(2.toShort()..1.toShort(), 1.toShort()..0.toShort()) + assertEquals(2.toByte()..1.toByte(), 1.toByte()..0.toByte()) + assertEquals(0f..-3.14f, 3.14f..0f) + assertEquals(-2.0..-3.0, 3.0..2.0) + assertEquals('b'..'a', 'c'..'b') + + assertTrue(1 downTo 2 == 2 downTo 3) + assertTrue(-1L downTo 0L == -2L downTo -1L) + assertEquals(-1f downTo 1f, -2f downTo 2f) + assertEquals(-4.0 downTo -3.0, -2.0 downTo -1.0) + assertEquals('j'..'a' step 4, 'u'..'q' step 2) + + assertFalse(0..1 == IntRange.EMPTY) + assertFalse(1f downTo 2f == 2f downTo 1f) + + assertEquals("range".."progression", "hashcode".."equals") + assertFalse(("aa".."bb") == ("aaa".."bbb")) + } + + test fun emptyHashCode() { + assertEquals((0..42).hashCode(), (0..42).hashCode()) + assertEquals((1.23..4.56).hashCode(), (1.23..4.56).hashCode()) + + assertEquals((0..-1).hashCode(), IntRange.EMPTY.hashCode()) + assertEquals((2L..1L).hashCode(), (1L..0L).hashCode()) + assertEquals((0.toShort()..-1.toShort()).hashCode(), (42.toShort()..0.toShort()).hashCode()) + assertEquals((0.toByte()..-1.toByte()).hashCode(), (42.toByte()..0.toByte()).hashCode()) + assertEquals((0f..-3.14f).hashCode(), (2.39f..1.41f).hashCode()) + assertEquals((0.0..-10.0).hashCode(), (10.0..0.0).hashCode()) + assertEquals(('z'..'x').hashCode(), ('l'..'k').hashCode()) + + assertEquals((1 downTo 2).hashCode(), (2 downTo 3).hashCode()) + assertEquals((1L downTo 2L).hashCode(), (2L downTo 3L).hashCode()) + assertEquals((1.0 downTo 2.0).hashCode(), (2.0 downTo 3.0).hashCode()) + assertEquals(('a' downTo 'b').hashCode(), ('c' downTo 'd').hashCode()) + + assertEquals(("range".."progression").hashCode(), ("hashcode".."equals").hashCode()) } test fun comparableRange() { @@ -131,5 +211,7 @@ public class RangeTest { assertFalse("item" in range) assertFalse("trail" in range) + + assertFalse(range.isEmpty()) } } \ No newline at end of file diff --git a/libraries/stdlib/test/language/RangeTestJVM.kt b/libraries/stdlib/test/language/RangeTestJVM.kt index 94c01200c7f..61239dff283 100644 --- a/libraries/stdlib/test/language/RangeTestJVM.kt +++ b/libraries/stdlib/test/language/RangeTestJVM.kt @@ -15,7 +15,7 @@ public class RangeTestJVM { } test fun floatRange() { - val range = -1.0.toFloat()..3.14159.toFloat() + val range = -1.0f..3.14159f assertFalse(jFloat.NEGATIVE_INFINITY in range) assertFalse(jFloat.POSITIVE_INFINITY in range) @@ -30,48 +30,48 @@ public class RangeTestJVM { failsWith(javaClass()) { LongProgression(0, 5, 0) } failsWith(javaClass()) { CharProgression('a', 'z', 0) } failsWith(javaClass()) { DoubleProgression(0.0, 5.0, 0.0) } - failsWith(javaClass()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), 0.0.toFloat()) } + failsWith(javaClass()) { FloatProgression(0.0f, 5.0f, 0.0f) } failsWith(javaClass()) { 0..5 step 0 } failsWith(javaClass()) { 0.toByte()..5.toByte() step 0 } failsWith(javaClass()) { 0.toShort()..5.toShort() step 0 } - failsWith(javaClass()) { 0.toLong()..5.toLong() step 0.toLong() } + failsWith(javaClass()) { 0L..5L step 0L } failsWith(javaClass()) { 'a'..'z' step 0 } failsWith(javaClass()) { 0.0..5.0 step 0.0 } - failsWith(javaClass()) { 0.0.toFloat()..5.0.toFloat() step 0.0.toFloat() } + failsWith(javaClass()) { 0.0f..5.0f step 0.0f } failsWith(javaClass()) { 0 downTo -5 step 0 } failsWith(javaClass()) { 0.toByte() downTo -5.toByte() step 0 } failsWith(javaClass()) { 0.toShort() downTo -5.toShort() step 0 } - failsWith(javaClass()) { 0.toLong() downTo -5.toLong() step 0.toLong() } + failsWith(javaClass()) { 0L downTo -5L step 0L } failsWith(javaClass()) { 'z' downTo 'a' step 0 } failsWith(javaClass()) { 0.0 downTo -5.0 step 0.0 } - failsWith(javaClass()) { 0.0.toFloat() downTo -5.0.toFloat() step 0.0.toFloat() } + failsWith(javaClass()) { 0.0f downTo -5.0f step 0.0f } failsWith(javaClass()) { 0..5 step -2 } failsWith(javaClass()) { 0.toByte()..5.toByte() step -2 } failsWith(javaClass()) { 0.toShort()..5.toShort() step -2 } - failsWith(javaClass()) { 0.toLong()..5.toLong() step -2.toLong() } + failsWith(javaClass()) { 0L..5L step -2L } failsWith(javaClass()) { 'a'..'z' step -2 } failsWith(javaClass()) { 0.0..5.0 step -0.5 } - failsWith(javaClass()) { 0.0.toFloat()..5.0.toFloat() step -0.5.toFloat() } + failsWith(javaClass()) { 0.0f..5.0f step -0.5f } failsWith(javaClass()) { 0 downTo -5 step -2 } failsWith(javaClass()) { 0.toByte() downTo -5.toByte() step -2 } failsWith(javaClass()) { 0.toShort() downTo -5.toShort() step -2 } - failsWith(javaClass()) { 0.toLong() downTo -5.toLong() step -2.toLong() } + failsWith(javaClass()) { 0L downTo -5L step -2L } failsWith(javaClass()) { 'z' downTo 'a' step -2 } failsWith(javaClass()) { 0.0 downTo -5.0 step -0.5 } - failsWith(javaClass()) { 0.0.toFloat() downTo -5.0.toFloat() step -0.5.toFloat() } + failsWith(javaClass()) { 0.0f downTo -5.0f step -0.5f } // NaN increment or step failsWith(javaClass()) { DoubleProgression(0.0, 5.0, jDouble.NaN) } - failsWith(javaClass()) { FloatProgression(0.0.toFloat(), 5.0.toFloat(), jFloat.NaN) } + failsWith(javaClass()) { FloatProgression(0.0f, 5.0f, jFloat.NaN) } failsWith(javaClass()) { 0.0..5.0 step jDouble.NaN } - failsWith(javaClass()) { 0.0.toFloat()..5.0.toFloat() step jFloat.NaN } + failsWith(javaClass()) { 0.0f..5.0f step jFloat.NaN } failsWith(javaClass()) { 5.0 downTo 0.0 step jDouble.NaN } - failsWith(javaClass()) { 5.0.toFloat() downTo 0.0.toFloat() step jFloat.NaN } + failsWith(javaClass()) { 5.0f downTo 0.0f step jFloat.NaN } } } \ No newline at end of file diff --git a/libraries/stdlib/test/text/StringTest.kt b/libraries/stdlib/test/text/StringTest.kt index d4e033de4ec..a1d584ec0fc 100644 --- a/libraries/stdlib/test/text/StringTest.kt +++ b/libraries/stdlib/test/text/StringTest.kt @@ -62,4 +62,10 @@ class StringTest { assertEquals("4321", "1234".reverse()) assertEquals("", "".reverse()) } + + test fun indices() { + assertEquals(0..4, "abcde".indices) + assertEquals(0..0, "a".indices) + assertEquals(IntRange.EMPTY, "".indices) + } }