From aa0dde3a78428796baaad4823e4283ec34ecd6ba Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 5 Feb 2014 09:51:32 +0100 Subject: [PATCH] Old implementation of JavaDescriptorResolver deleted --- ...lang.resolve.java.resolver.ProgressChecker | 1 - .../java/resolver/ProgressCheckerImpl.java | 26 -- .../ClassDescriptorFromJvmBytecode.java | 89 ----- .../JavaPackageFragmentDescriptorImpl.java | 107 ----- .../jet/lang/resolve/java/lazy/context.kt | 1 - .../resolver/DescriptorResolverUtils.java | 5 - .../JavaAnnotationArgumentResolver.java | 165 -------- .../java/resolver/JavaAnnotationResolver.java | 164 -------- .../java/resolver/JavaClassResolver.java | 374 ------------------ .../resolver/JavaConstructorResolver.java | 212 ---------- .../java/resolver/JavaFunctionResolver.java | 246 ------------ .../java/resolver/JavaMemberResolver.java | 76 ---- .../JavaPackageFragmentProviderImpl.java | 191 --------- .../java/resolver/JavaPropertyResolver.java | 146 ------- .../java/resolver/JavaSupertypeResolver.java | 100 ----- .../resolver/JavaTypeParameterResolver.java | 107 ----- .../java/resolver/JavaTypeTransformer.java | 278 ------------- .../resolver/JavaValueParameterResolver.java | 113 ------ .../resolve/java/resolver/PostponedTasks.java | 38 -- .../java/resolver/ProgressChecker.java | 39 -- .../java/resolver/TypeVariableResolver.java | 35 -- .../resolver/TypeVariableResolverImpl.java | 75 ---- .../resolve/java/scope/JavaBaseScope.java | 165 -------- .../java/scope/JavaClassMembersScope.java | 66 ---- .../scope/JavaClassNonStaticMembersScope.java | 118 ------ .../scope/JavaClassStaticMembersScope.java | 64 --- .../java/scope/JavaEnumClassObjectScope.java | 42 -- .../java/scope/JavaFullPackageScope.java | 43 -- .../java/scope/JavaPackageFragmentScope.java | 26 -- .../java/scope/JavaPurePackageScope.java | 145 ------- .../lang/resolve/java/scope/MembersCache.java | 258 ------------ .../resolve/java/scope/MembersProvider.java | 77 ---- .../lang/resolve/java/scope/NamedMembers.java | 83 ---- 33 files changed, 3675 deletions(-) delete mode 100644 compiler/frontend.java/src/META-INF/services/org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressCheckerImpl.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptorImpl.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProviderImpl.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PostponedTasks.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressChecker.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaEnumClassObjectScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaFullPackageScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageFragmentScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPurePackageScope.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersCache.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/NamedMembers.java diff --git a/compiler/frontend.java/src/META-INF/services/org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker b/compiler/frontend.java/src/META-INF/services/org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker deleted file mode 100644 index 402eb2541c0..00000000000 --- a/compiler/frontend.java/src/META-INF/services/org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker +++ /dev/null @@ -1 +0,0 @@ -org.jetbrains.jet.lang.resolve.java.resolver.ProgressCheckerImpl diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressCheckerImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressCheckerImpl.java deleted file mode 100644 index 0b658bfdd28..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressCheckerImpl.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import com.intellij.openapi.progress.ProgressIndicatorProvider; - -public class ProgressCheckerImpl extends ProgressChecker { - @Override - public void checkCanceled() { - ProgressIndicatorProvider.checkCanceled(); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java deleted file mode 100644 index 46d4de9344f..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright 2010-2013 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.java.descriptor; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassKind; -import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite; -import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.JetType; - -import java.util.Collection; - -/** - * @see org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor - */ -public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite implements JavaClassDescriptor { - private JetType functionTypeForSamInterface; - private JavaClassNonStaticMembersScope scopeForConstructorResolve; - private ConstructorDescriptor primaryConstructor; - private Collection constructors; - - public ClassDescriptorFromJvmBytecode( - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull Name name, - @NotNull ClassKind kind, - boolean isInner - ) { - super(containingDeclaration, name, kind, isInner); - } - - @NotNull - @Override - public Collection getConstructors() { - assert scopeForConstructorResolve != null; - if (constructors == null) { - constructors = scopeForConstructorResolve.getConstructors(); - } - return constructors; - } - - @Nullable - @Override - public ConstructorDescriptor getUnsubstitutedPrimaryConstructor() { - if (primaryConstructor == null) { - for (ConstructorDescriptor constructor : getConstructors()) { - if (constructor.isPrimary()) { - if (primaryConstructor != null) { - throw new IllegalStateException( - "Class has more than one primary constructor: " + primaryConstructor + "\n" + constructor); - } - primaryConstructor = constructor; - } - } - } - return primaryConstructor; - } - - public void setScopeForConstructorResolve(@NotNull JavaClassNonStaticMembersScope scopeForConstructorResolve) { - this.scopeForConstructorResolve = scopeForConstructorResolve; - } - - @Override - @Nullable - public JetType getFunctionTypeForSamInterface() { - return functionTypeForSamInterface; - } - - public void setFunctionTypeForSamInterface(@NotNull JetType functionTypeForSamInterface) { - this.functionTypeForSamInterface = functionTypeForSamInterface; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptorImpl.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptorImpl.java deleted file mode 100644 index 6ea314568c7..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptorImpl.java +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright 2010-2013 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.java.descriptor; - -import com.intellij.util.NullableFunction; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; -import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; -import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageFragmentScope; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.types.TypeSubstitutor; - -public class JavaPackageFragmentDescriptorImpl extends DeclarationDescriptorImpl implements JavaPackageFragmentDescriptor { - @Nullable - public static JavaPackageFragmentDescriptorImpl create( - @NotNull JavaPackageFragmentProvider provider, - @NotNull FqName fqName, - @NotNull NullableFunction scopeFactory - ) { - JavaPackageFragmentDescriptorImpl descriptor = new JavaPackageFragmentDescriptorImpl(provider, fqName, scopeFactory); - return descriptor.memberScope == null ? null : descriptor; - } - - private final JavaPackageFragmentProvider provider; - private final FqName fqName; - - private final JavaPackageFragmentScope memberScope; - - private JavaPackageFragmentDescriptorImpl( - @NotNull JavaPackageFragmentProvider provider, - @NotNull FqName fqName, - @NotNull NullableFunction scopeFactory - ) { - super(Annotations.EMPTY, fqName.shortNameOrSpecial()); - this.provider = provider; - this.fqName = fqName; - this.memberScope = scopeFactory.fun(this); - } - - @NotNull - @Override - public Kind getKind() { - return memberScope instanceof JavaClassStaticMembersScope ? Kind.CLASS_STATICS : Kind.PROPER; - } - - @NotNull - @Override - public JavaDescriptorResolver getJavaDescriptorResolver() { - return provider.getJavaDescriptorResolver(); - } - - @NotNull - @Override - public ModuleDescriptor getContainingDeclaration() { - return provider.getModule(); - } - - @Nullable - @Override - public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) { - return this; - } - - @Override - public R accept(DeclarationDescriptorVisitor visitor, D data) { - return visitor.visitPackageFragmentDescriptor(this, data); - } - - @NotNull - @Override - public JavaPackageFragmentScope getMemberScope() { - return memberScope; - } - - @NotNull - @Override - public FqName getFqName() { - return fqName; - } - - @Override - @NotNull - public JavaPackageFragmentProvider getProvider() { - return provider; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/context.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/context.kt index 0b9482491e5..5990f402da6 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/context.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/context.kt @@ -31,7 +31,6 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder import org.jetbrains.jet.lang.resolve.name.FqName import org.jetbrains.jet.lang.resolve.java.structure.JavaClass -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver import org.jetbrains.jet.lang.descriptors.ClassDescriptor open class GlobalJavaResolverContext( diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java index cf57e49b2be..867c8ecb7bd 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java @@ -39,7 +39,6 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getFqNameSafe; -import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClassObject; public final class DescriptorResolverUtils { public static final FqName OBJECT_FQ_NAME = new FqName("java.lang.Object"); @@ -133,10 +132,6 @@ public final class DescriptorResolverUtils { "valueOf(java.lang.String)".equals(signature); } - public static boolean isCorrectOwnerForEnumMethod(@NotNull ClassOrPackageFragmentDescriptor ownerDescriptor, @NotNull JavaMethod method) { - return isEnumClassObject(ownerDescriptor) == shouldBeInEnumClassObject(method); - } - public static boolean isObjectMethodInInterface(@NotNull JavaMember member) { return member.getContainingClass().isInterface() && member instanceof JavaMethod && isObjectMethod((JavaMethod) member); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java deleted file mode 100644 index e453fb2198e..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationArgumentResolver.java +++ /dev/null @@ -1,165 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.resolve.constants.*; -import org.jetbrains.jet.lang.resolve.java.structure.*; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.JetTypeImpl; -import org.jetbrains.jet.lang.types.TypeProjectionImpl; -import org.jetbrains.jet.lang.types.TypeUtils; - -import javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; - -public final class JavaAnnotationArgumentResolver { - - private JavaAnnotationResolver annotationResolver; - private JavaClassResolver classResolver; - private JavaTypeTransformer typeTransformer; - - @Inject - public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setClassResolver(JavaClassResolver classResolver) { - this.classResolver = classResolver; - } - - @Inject - public void setTypeTransformer(JavaTypeTransformer typeTransformer) { - this.typeTransformer = typeTransformer; - } - - @Nullable - public CompileTimeConstant resolveAnnotationArgument( - @NotNull FqName annotationFqName, - @NotNull JavaAnnotationArgument argument, - @NotNull PostponedTasks postponedTasks - ) { - if (argument instanceof JavaLiteralAnnotationArgument) { - return ResolverPackage.resolveCompileTimeConstantValue(((JavaLiteralAnnotationArgument) argument).getValue(), true, null); - } - // Enum - else if (argument instanceof JavaReferenceAnnotationArgument) { - return resolveFromReference(((JavaReferenceAnnotationArgument) argument).resolve(), postponedTasks); - } - // Array - else if (argument instanceof JavaArrayAnnotationArgument) { - Name argumentName = argument.getName(); - return resolveFromArray( - annotationFqName, - argumentName == null ? JavaAnnotationResolver.DEFAULT_ANNOTATION_MEMBER_NAME : argumentName, - ((JavaArrayAnnotationArgument) argument).getElements(), - postponedTasks - ); - } - // Annotation - else if (argument instanceof JavaAnnotationAsAnnotationArgument) { - return resolveFromAnnotation(((JavaAnnotationAsAnnotationArgument) argument).getAnnotation(), postponedTasks); - } - // Class - else if (argument instanceof JavaClassObjectAnnotationArgument) { - return resolveFromJavaClassObjectType(((JavaClassObjectAnnotationArgument) argument).getReferencedType()); - } - - return null; - } - - @Nullable - private CompileTimeConstant resolveFromAnnotation(@NotNull JavaAnnotation value, @NotNull PostponedTasks taskList) { - AnnotationDescriptor descriptor = annotationResolver.resolveAnnotation(value, taskList); - return descriptor == null ? null : new AnnotationValue(descriptor); - } - - @Nullable - private CompileTimeConstant resolveFromArray( - @NotNull FqName annotationFqName, - @NotNull Name argumentName, - @NotNull List elements, - @NotNull PostponedTasks taskList - ) { - ClassDescriptor annotationClass = classResolver.resolveClass(annotationFqName, INCLUDE_KOTLIN_SOURCES, taskList); - if (annotationClass == null) return null; - - //TODO: nullability issues - ValueParameterDescriptor valueParameter = DescriptorResolverUtils.getAnnotationParameterByName(argumentName, annotationClass); - if (valueParameter == null) return null; - - List> values = new ArrayList>(elements.size()); - for (JavaAnnotationArgument argument : elements) { - CompileTimeConstant value = resolveAnnotationArgument(annotationFqName, argument, taskList); - values.add(value == null ? NullValue.NULL : value); - } - - return new ArrayValue(values, valueParameter.getType(), true); - } - - @Nullable - private CompileTimeConstant resolveFromReference(@Nullable JavaElement element, @NotNull PostponedTasks taskList) { - if (!(element instanceof JavaField)) return null; - - JavaField field = (JavaField) element; - if (!field.isEnumEntry()) return null; - - FqName fqName = field.getContainingClass().getFqName(); - if (fqName == null) return null; - - ClassDescriptor enumClass = classResolver.resolveClass(fqName, INCLUDE_KOTLIN_SOURCES, taskList); - if (enumClass == null) return null; - - ClassifierDescriptor classifier = enumClass.getUnsubstitutedInnerClassesScope().getClassifier(field.getName()); - if (!(classifier instanceof ClassDescriptor)) return null; - - return new EnumValue((ClassDescriptor) classifier); - } - - @Nullable - private CompileTimeConstant resolveFromJavaClassObjectType(@NotNull JavaType javaType) { - // Foo.class is never nullable - JetType type = TypeUtils.makeNotNullable(typeTransformer.transformToType(javaType, TypeVariableResolver.EMPTY)); - - ClassDescriptor jlClass = classResolver.resolveClass(JL_CLASS_FQ_NAME, IGNORE_KOTLIN_SOURCES); - if (jlClass == null) return null; - - List arguments = Collections.singletonList(new TypeProjectionImpl(type)); - JetTypeImpl javaClassType = new JetTypeImpl( - jlClass.getAnnotations(), - jlClass.getTypeConstructor(), - false, - arguments, - jlClass.getMemberScope(arguments) - ); - - return new JavaClassValue(javaClassType); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java deleted file mode 100644 index b2415796c2f..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ /dev/null @@ -1,164 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationsImpl; -import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; -import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation; -import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationArgument; -import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationOwner; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; - -import javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; -import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; - -public final class JavaAnnotationResolver { - - private JavaClassResolver classResolver; - private JavaAnnotationArgumentResolver argumentResolver; - private ExternalAnnotationResolver externalAnnotationResolver; - - public JavaAnnotationResolver() { - } - - @Inject - public void setClassResolver(JavaClassResolver classResolver) { - this.classResolver = classResolver; - } - - @Inject - public void setArgumentResolver(JavaAnnotationArgumentResolver argumentResolver) { - this.argumentResolver = argumentResolver; - } - - @Inject - public void setExternalAnnotationResolver(ExternalAnnotationResolver externalAnnotationResolver) { - this.externalAnnotationResolver = externalAnnotationResolver; - } - - private void resolveAnnotations( - @NotNull Collection annotations, - @NotNull PostponedTasks tasks, - @NotNull List result - ) { - for (JavaAnnotation javaAnnotation : annotations) { - AnnotationDescriptor annotation = resolveAnnotation(javaAnnotation, tasks); - if (annotation != null) { - result.add(annotation); - } - } - } - - @NotNull - public Annotations resolveAnnotations(@NotNull JavaAnnotationOwner owner, @NotNull PostponedTasks tasks) { - List result = new ArrayList(); - resolveAnnotations(owner.getAnnotations(), tasks, result); - resolveAnnotations(externalAnnotationResolver.findExternalAnnotations(owner), tasks, result); - return new AnnotationsImpl(result); - } - - @NotNull - public Annotations resolveAnnotations(@NotNull JavaAnnotationOwner owner) { - PostponedTasks postponedTasks = new PostponedTasks(); - Annotations annotations = resolveAnnotations(owner, postponedTasks); - postponedTasks.performTasks(); - return annotations; - } - - @Nullable - public AnnotationDescriptor resolveAnnotation(@NotNull JavaAnnotation javaAnnotation, @NotNull PostponedTasks postponedTasks) { - final AnnotationDescriptorImpl annotation = new AnnotationDescriptorImpl(); - FqName fqName = javaAnnotation.getFqName(); - if (fqName == null) { - return null; - } - - // Don't process internal jet annotations and jetbrains NotNull annotations - if (isSpecialAnnotation(fqName)) { - return null; - } - - AnnotationDescriptor mappedClassDescriptor = JavaToKotlinClassMap.getInstance().mapToAnnotationClass(fqName); - if (mappedClassDescriptor != null) { - return mappedClassDescriptor; - } - - final ClassDescriptor annotationClass = classResolver.resolveClass(fqName, INCLUDE_KOTLIN_SOURCES, postponedTasks); - if (annotationClass == null) { - return null; - } - - postponedTasks.addTask(new Runnable() { - @Override - public void run() { - annotation.setAnnotationType(annotationClass.getDefaultType()); - } - }); - - - for (JavaAnnotationArgument argument : javaAnnotation.getArguments()) { - CompileTimeConstant value = argumentResolver.resolveAnnotationArgument(fqName, argument, postponedTasks); - if (value == null) continue; - - Name name = argument.getName(); - ValueParameterDescriptor descriptor = DescriptorResolverUtils.getAnnotationParameterByName( - name == null ? DEFAULT_ANNOTATION_MEMBER_NAME : name, annotationClass); - if (descriptor != null) { - annotation.setValueArgument(descriptor, value); - } - } - - return annotation; - } - - @Nullable - public JavaAnnotation findAnnotationWithExternal(@NotNull JavaAnnotationOwner owner, @NotNull FqName name) { - JavaAnnotation annotation = owner.findAnnotation(name); - if (annotation != null) { - return annotation; - } - - return externalAnnotationResolver.findExternalAnnotation(owner, name); - } - - public boolean hasNotNullAnnotation(@NotNull JavaAnnotationOwner owner) { - return findAnnotationWithExternal(owner, JETBRAINS_NOT_NULL_ANNOTATION) != null; - } - - public boolean hasMutableAnnotation(@NotNull JavaAnnotationOwner owner) { - return findAnnotationWithExternal(owner, JETBRAINS_MUTABLE_ANNOTATION) != null; - } - - public boolean hasReadonlyAnnotation(@NotNull JavaAnnotationOwner owner) { - return findAnnotationWithExternal(owner, JETBRAINS_READONLY_ANNOTATION) != null; - } -} \ No newline at end of file diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java deleted file mode 100644 index 7a7c8a9509c..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ /dev/null @@ -1,374 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.DescriptorFactory; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -import org.jetbrains.jet.lang.resolve.java.JavaClassFinder; -import org.jetbrains.jet.lang.resolve.java.JvmAbi; -import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaEnumClassObjectDescriptor; -import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; -import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; -import org.jetbrains.jet.lang.resolve.java.scope.JavaEnumClassObjectScope; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; -import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; -import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder; -import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass; -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.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; - -import javax.inject.Inject; -import java.util.*; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; -import static org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName; - -public final class JavaClassResolver { - @NotNull - private final Map classDescriptorCache = new HashMap(); - - @NotNull - private final Set unresolvedCache = new HashSet(); - - private JavaResolverCache cache; - private JavaTypeParameterResolver typeParameterResolver; - private JavaMemberResolver memberResolver; - private JavaAnnotationResolver annotationResolver; - private JavaClassFinder javaClassFinder; - private JavaPackageFragmentProvider packageFragmentProvider; - private JavaSupertypeResolver supertypesResolver; - private JavaFunctionResolver functionResolver; - private DeserializedDescriptorResolver deserializedDescriptorResolver; - private KotlinClassFinder kotlinClassFinder; - - public JavaClassResolver() { - } - - @Inject - public void setCache(JavaResolverCache cache) { - this.cache = cache; - } - - @Inject - public void setDeserializedDescriptorResolver(DeserializedDescriptorResolver deserializedDescriptorResolver) { - this.deserializedDescriptorResolver = deserializedDescriptorResolver; - } - - @Inject - public void setTypeParameterResolver(JavaTypeParameterResolver typeParameterResolver) { - this.typeParameterResolver = typeParameterResolver; - } - - @Inject - public void setMemberResolver(JavaMemberResolver memberResolver) { - this.memberResolver = memberResolver; - } - - @Inject - public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setJavaClassFinder(JavaClassFinder javaClassFinder) { - this.javaClassFinder = javaClassFinder; - } - - @Inject - public void setPackageFragmentProvider(JavaPackageFragmentProvider packageFragmentProvider) { - this.packageFragmentProvider = packageFragmentProvider; - } - - @Inject - public void setSupertypesResolver(JavaSupertypeResolver supertypesResolver) { - this.supertypesResolver = supertypesResolver; - } - - @Inject - public void setFunctionResolver(JavaFunctionResolver functionResolver) { - this.functionResolver = functionResolver; - } - - @Inject - public void setKotlinClassFinder(KotlinClassFinder kotlinClassFinder) { - this.kotlinClassFinder = kotlinClassFinder; - } - - @Nullable - public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { - PostponedTasks postponedTasks = new PostponedTasks(); - ClassDescriptor classDescriptor = resolveClass(qualifiedName, searchRule, postponedTasks); - postponedTasks.performTasks(); - return classDescriptor; - } - - @Nullable - public ClassDescriptor resolveClass( - @NotNull FqName qualifiedName, - @NotNull DescriptorSearchRule searchRule, - @NotNull PostponedTasks tasks - ) { - if (isTraitImplementation(qualifiedName)) { - return null; - } - - ClassDescriptor builtinClassDescriptor = getKotlinBuiltinClassDescriptor(qualifiedName); - if (builtinClassDescriptor != null) { - return builtinClassDescriptor; - } - - if (searchRule == INCLUDE_KOTLIN_SOURCES) { - ClassDescriptor kotlinClassDescriptor = cache.getClassResolvedFromSource(qualifiedName); - if (kotlinClassDescriptor != null) { - return kotlinClassDescriptor; - } - } - - FqNameUnsafe fqName = javaClassToKotlinFqName(qualifiedName); - ClassDescriptor cachedDescriptor = classDescriptorCache.get(fqName); - if (cachedDescriptor != null) { - return cachedDescriptor; - } - - if (unresolvedCache.contains(fqName)) { - return null; - } - - return doResolveClass(qualifiedName, tasks); - } - - private ClassDescriptor doResolveClass(@NotNull FqName qualifiedName, @NotNull PostponedTasks tasks) { - //TODO: correct scope - KotlinJvmBinaryClass kotlinClass = kotlinClassFinder.findKotlinClass(qualifiedName); - if (kotlinClass != null) { - ClassDescriptor deserializedDescriptor = deserializedDescriptorResolver.resolveClass(kotlinClass); - if (deserializedDescriptor != null) { - cache(javaClassToKotlinFqName(qualifiedName), deserializedDescriptor); - return deserializedDescriptor; - } - } - - JavaClass javaClass = javaClassFinder.findClass(qualifiedName); - if (javaClass == null) { - cacheNegativeValue(javaClassToKotlinFqName(qualifiedName)); - return null; - } - - // Class may have been resolved previously by different Java resolver instance, and we are reusing its trace - ClassDescriptor alreadyResolved = cache.getClass(javaClass); - if (alreadyResolved != null) { - return alreadyResolved; - } - - ClassOrPackageFragmentDescriptor containingDeclaration = resolveParentDescriptor(qualifiedName, javaClass.getOuterClass()); - // class may be resolved during resolution of parent - ClassDescriptor cachedDescriptor = classDescriptorCache.get(javaClassToKotlinFqName(qualifiedName)); - if (cachedDescriptor != null) { - return cachedDescriptor; - } - assert !unresolvedCache.contains(qualifiedName.toUnsafe()) - : "We can resolve the class, so it can't be 'unresolved' during parent resolution"; - - checkFqNamesAreConsistent(javaClass, qualifiedName); - - assert javaClass.getOriginKind() != JavaClass.OriginKind.KOTLIN_LIGHT_CLASS : - "Trying to resolve a light class as a regular PsiClass: " + javaClass.getFqName(); - - return doCreateClassDescriptor(qualifiedName, javaClass, tasks, containingDeclaration); - } - - private void cacheNegativeValue(@NotNull FqNameUnsafe fqNameUnsafe) { - if (classDescriptorCache.containsKey(fqNameUnsafe)) { - throw new IllegalStateException("rewrite at " + fqNameUnsafe); - } - unresolvedCache.add(fqNameUnsafe); - } - - private static boolean isTraitImplementation(@NotNull FqName qualifiedName) { - // TODO: only if -$$TImpl class is created by Kotlin - return qualifiedName.asString().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX); - } - - @NotNull - private JavaClassDescriptor doCreateClassDescriptor( - @NotNull FqName fqName, - @NotNull JavaClass javaClass, - @NotNull PostponedTasks taskList, - @NotNull ClassOrPackageFragmentDescriptor containingDeclaration - ) { - ClassDescriptorFromJvmBytecode classDescriptor = - new ClassDescriptorFromJvmBytecode(containingDeclaration, javaClass.getName(), determineClassKind(javaClass), isInnerClass(javaClass)); - - cache(javaClassToKotlinFqName(fqName), classDescriptor); - - - JavaTypeParameterResolver.Initializer typeParameterInitializer = typeParameterResolver.resolveTypeParameters(classDescriptor, javaClass); - classDescriptor.setTypeParameterDescriptors(typeParameterInitializer.getDescriptors()); - - List supertypes = new ArrayList(); - classDescriptor.setSupertypes(supertypes); - classDescriptor.setVisibility(javaClass.getVisibility()); - classDescriptor.setModality(determineClassModality(javaClass)); - classDescriptor.createTypeConstructor(); - - JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, javaClass, memberResolver); - classDescriptor.setScopeForMemberLookup(scope); - classDescriptor.setScopeForConstructorResolve(scope); - - typeParameterInitializer.initialize(); - - // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes - List classTypeParameters = classDescriptor.getTypeConstructor().getParameters(); - supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, javaClass, classTypeParameters)); - - if (javaClass.isEnum()) { - JavaEnumClassObjectDescriptor enumClassObject = createEnumClassObject(classDescriptor, javaClass); - createEnumSyntheticMethods(enumClassObject, classDescriptor.getDefaultType()); - cache(getFqNameForClassObject(javaClass), enumClassObject); - classDescriptor.getBuilder().setClassObjectDescriptor(enumClassObject); - } - - classDescriptor.setAnnotations(annotationResolver.resolveAnnotations(javaClass, taskList)); - - cache.recordClass(javaClass, classDescriptor); - - JavaMethod samInterfaceMethod = SingleAbstractMethodUtils.getSamInterfaceMethod(javaClass); - if (samInterfaceMethod != null) { - SimpleFunctionDescriptor abstractMethod = resolveFunctionOfSamInterface(samInterfaceMethod, classDescriptor); - classDescriptor.setFunctionTypeForSamInterface(SingleAbstractMethodUtils.getFunctionTypeForAbstractMethod(abstractMethod)); - } - - return classDescriptor; - } - - @NotNull - public static FqNameUnsafe getFqNameForClassObject(@NotNull JavaClass javaClass) { - FqName fqName = javaClass.getFqName(); - assert fqName != null : "Reading java class with no qualified name"; - return fqName.toUnsafe().child(getClassObjectName(javaClass.getName())); - } - - @NotNull - private SimpleFunctionDescriptor resolveFunctionOfSamInterface( - @NotNull JavaMethod samInterfaceMethod, - @NotNull JavaClassDescriptor samInterface - ) { - JavaClass methodContainer = samInterfaceMethod.getContainingClass(); - FqName containerFqName = methodContainer.getFqName(); - assert containerFqName != null : "qualified name is null for " + methodContainer; - - if (DescriptorUtils.getFqName(samInterface).equalsTo(containerFqName)) { - SimpleFunctionDescriptor abstractMethod = functionResolver.resolveFunctionMutely(samInterfaceMethod, samInterface); - assert abstractMethod != null : "couldn't resolve method " + samInterfaceMethod; - return abstractMethod; - } - else { - return findFunctionWithMostSpecificReturnType(TypeUtils.getAllSupertypes(samInterface.getDefaultType())); - } - } - - private void cache(@NotNull FqNameUnsafe fqName, @Nullable ClassDescriptor classDescriptor) { - if (classDescriptor == null) { - cacheNegativeValue(fqName); - } - else { - ClassDescriptor oldValue = classDescriptorCache.put(fqName, classDescriptor); - assert oldValue == null; - } - } - - private void checkFqNamesAreConsistent(@NotNull JavaClass javaClass, @NotNull FqName desiredFqName) { - FqName fqName = javaClass.getFqName(); - assert desiredFqName.equals(fqName) : "Inconsistent FQ names: " + fqName + ", " + desiredFqName; - FqNameUnsafe correctedName = javaClassToKotlinFqName(fqName); - if (classDescriptorCache.containsKey(correctedName) || unresolvedCache.contains(correctedName)) { - throw new IllegalStateException("Cache already contains FQ name: " + fqName.asString()); - } - } - - @NotNull - private ClassOrPackageFragmentDescriptor resolveParentDescriptor(@NotNull FqName childClassFQName, JavaClass parentClass) { - if (parentClass != null) { - FqName parentFqName = parentClass.getFqName(); - ClassDescriptor parentClassDescriptor = resolveClass(parentFqName, INCLUDE_KOTLIN_SOURCES); - if (parentClassDescriptor == null) { - throw new IllegalStateException("Could not resolve " + parentFqName + " required to be parent for " + childClassFQName); - } - return parentClassDescriptor; - } - else { - FqName parentFqName = childClassFQName.parent(); - PackageFragmentDescriptor parentPackage = packageFragmentProvider.getPackageFragment(parentFqName); - if (parentPackage == null) { - throw new IllegalStateException("Could not resolve " + parentFqName + " required to be parent for " + childClassFQName); - } - return parentPackage; - } - } - - // This method replaces "object" segments of FQ name to "" - @NotNull - private static FqNameUnsafe javaClassToKotlinFqName(@NotNull FqName rawFqName) { - List correctedSegments = new ArrayList(); - for (Name segment : rawFqName.pathSegments()) { - if (JvmAbi.CLASS_OBJECT_CLASS_NAME.equals(segment.asString())) { - assert !correctedSegments.isEmpty(); - Name previous = correctedSegments.get(correctedSegments.size() - 1); - correctedSegments.add(getClassObjectName(previous)); - } - else { - correctedSegments.add(segment); - } - } - return FqNameUnsafe.fromSegments(correctedSegments); - } - - @NotNull - private JavaEnumClassObjectDescriptor createEnumClassObject(@NotNull ClassDescriptor enumClass, @NotNull JavaClass javaClass) { - JavaEnumClassObjectDescriptor classObject = new JavaEnumClassObjectDescriptor(enumClass); - - classObject.setSupertypes(Collections.singleton(KotlinBuiltIns.getInstance().getAnyType())); - classObject.setModality(Modality.FINAL); - classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility()); - classObject.setTypeParameterDescriptors(Collections.emptyList()); - classObject.createTypeConstructor(); - - JavaEnumClassObjectScope scope = new JavaEnumClassObjectScope(classObject, javaClass, memberResolver); - WritableScopeImpl writableScope = - new WritableScopeImpl(scope, classObject, RedeclarationHandler.THROW_EXCEPTION, "Enum class object scope"); - writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); - classObject.setScopeForMemberLookup(writableScope); - - return classObject; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java deleted file mode 100644 index b2a4b207151..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ /dev/null @@ -1,212 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; -import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; -import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; -import org.jetbrains.jet.lang.resolve.java.structure.JavaType; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; - -import javax.inject.Inject; -import java.util.*; - -import static org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils.createSamAdapterConstructor; -import static org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils.isSamAdapterNecessary; - -public final class JavaConstructorResolver { - private JavaResolverCache cache; - private JavaTypeTransformer typeTransformer; - private JavaValueParameterResolver valueParameterResolver; - private ExternalSignatureResolver externalSignatureResolver; - - public JavaConstructorResolver() { - } - - @Inject - public void setCache(JavaResolverCache cache) { - this.cache = cache; - } - - @Inject - public void setTypeTransformer(JavaTypeTransformer typeTransformer) { - this.typeTransformer = typeTransformer; - } - - @Inject - public void setValueParameterResolver(JavaValueParameterResolver valueParameterResolver) { - this.valueParameterResolver = valueParameterResolver; - } - - @Inject - public void setExternalSignatureResolver(ExternalSignatureResolver externalSignatureResolver) { - this.externalSignatureResolver = externalSignatureResolver; - } - - @NotNull - public Collection resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor containingClass) { - Collection result = new ArrayList(); - - Collection constructors = javaClass.getConstructors(); - - if (constructors.isEmpty()) { - ConstructorDescriptor defaultConstructor = resolveDefaultConstructor(javaClass, containingClass); - if (defaultConstructor != null) { - result.add(defaultConstructor); - } - } - else { - for (JavaMethod constructor : constructors) { - ConstructorDescriptor descriptor = resolveConstructor(constructor, containingClass, javaClass.isStatic()); - result.add(descriptor); - ConstructorDescriptor samAdapter = resolveSamAdapter(descriptor); - if (samAdapter != null) { - result.add(samAdapter); - } - } - } - - for (ConstructorDescriptor constructor : result) { - ((ConstructorDescriptorImpl) constructor).setReturnType(containingClass.getDefaultType()); - } - - return result; - } - - @Nullable - private ConstructorDescriptor resolveDefaultConstructor(@NotNull JavaClass javaClass, @NotNull ClassDescriptor containingClass) { - ConstructorDescriptor alreadyResolved = cache.getConstructor(javaClass); - if (alreadyResolved != null) { - return alreadyResolved; - } - - boolean isAnnotation = javaClass.isAnnotationType(); - - if (javaClass.isInterface() && !isAnnotation) return null; - - ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( - containingClass, - Annotations.EMPTY, - true); - - List typeParameters = containingClass.getTypeConstructor().getParameters(); - - List valueParameters; - if (isAnnotation) { - TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(typeParameters, containingClass); - valueParameters = resolveAnnotationParameters(javaClass, constructorDescriptor, typeVariableResolver); - } - else { - valueParameters = Collections.emptyList(); - } - - constructorDescriptor.initialize(typeParameters, valueParameters, getConstructorVisibility(containingClass), javaClass.isStatic()); - - cache.recordConstructor(javaClass, constructorDescriptor); - - return constructorDescriptor; - } - - @NotNull - private List resolveAnnotationParameters( - @NotNull JavaClass javaClass, - @NotNull ConstructorDescriptor constructorDescriptor, - @NotNull TypeVariableResolver typeVariableResolver - ) { - // A constructor for an annotation type takes all the "methods" in the @interface as parameters - Collection methods = javaClass.getMethods(); - List result = new ArrayList(methods.size()); - - int index = 0; - for (Iterator iterator = methods.iterator(); iterator.hasNext(); ) { - JavaMethod method = iterator.next(); - assert method.getValueParameters().isEmpty() : "Annotation method can't have parameters: " + method; - - JavaType returnType = method.getReturnType(); - assert returnType != null : "Annotation method has no return type: " + method; - - // We take the following heuristic convention: - // if the last method of the @interface is an array, we convert it into a vararg - JetType varargElementType = null; - if (!iterator.hasNext() && returnType instanceof JavaArrayType) { - JavaType componentType = ((JavaArrayType) returnType).getComponentType(); - varargElementType = typeTransformer.transformToType(componentType, typeVariableResolver); - } - - result.add(new ValueParameterDescriptorImpl( - constructorDescriptor, - index, - Annotations.EMPTY, - method.getName(), - // Parameters of annotation constructors in Java are never nullable - TypeUtils.makeNotNullable(typeTransformer.transformToType(returnType, typeVariableResolver)), - method.hasAnnotationParameterDefaultValue(), - varargElementType == null ? null : TypeUtils.makeNotNullable(varargElementType))); - - index++; - } - - return result; - } - - @NotNull - private ConstructorDescriptor resolveConstructor( - @NotNull JavaMethod constructor, - @NotNull ClassDescriptor classDescriptor, - boolean isStaticClass - ) { - ConstructorDescriptor alreadyResolved = cache.getConstructor(constructor); - if (alreadyResolved != null) { - return alreadyResolved; - } - - ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( - classDescriptor, - Annotations.EMPTY, // TODO - false); - - List typeParameters = classDescriptor.getTypeConstructor().getParameters(); - - List valueParameters = valueParameterResolver.resolveValueParameters( - constructorDescriptor, constructor, - new TypeVariableResolverImpl(typeParameters, classDescriptor) - ); - - ExternalSignatureResolver.AlternativeMethodSignature effectiveSignature = externalSignatureResolver - .resolveAlternativeMethodSignature(constructor, false, null, null, valueParameters, - Collections.emptyList()); - - constructorDescriptor - .initialize(typeParameters, effectiveSignature.getValueParameters(), constructor.getVisibility(), isStaticClass); - - List signatureErrors = effectiveSignature.getErrors(); - if (!signatureErrors.isEmpty()) { - externalSignatureResolver.reportSignatureErrors(constructorDescriptor, signatureErrors); - } - - cache.recordConstructor(constructor, constructorDescriptor); - return constructorDescriptor; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java deleted file mode 100644 index 3293310470c..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ /dev/null @@ -1,246 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.descriptor.*; -import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers; -import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; -import org.jetbrains.jet.lang.resolve.java.structure.JavaType; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; - -import javax.inject.Inject; -import java.util.*; - -import static org.jetbrains.jet.lang.resolve.DescriptorUtils.*; -import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.resolveOverrides; -import static org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils.*; - -public final class JavaFunctionResolver { - private JavaTypeTransformer typeTransformer; - private JavaResolverCache cache; - private JavaTypeParameterResolver typeParameterResolver; - private JavaValueParameterResolver valueParameterResolver; - private JavaAnnotationResolver annotationResolver; - private ExternalSignatureResolver externalSignatureResolver; - private ErrorReporter errorReporter; - private MethodSignatureChecker signatureChecker; - - @Inject - public void setTypeTransformer(JavaTypeTransformer typeTransformer) { - this.typeTransformer = typeTransformer; - } - - @Inject - public void setCache(JavaResolverCache cache) { - this.cache = cache; - } - - @Inject - public void setTypeParameterResolver(JavaTypeParameterResolver typeParameterResolver) { - this.typeParameterResolver = typeParameterResolver; - } - - @Inject - public void setValueParameterResolver(JavaValueParameterResolver valueParameterResolver) { - this.valueParameterResolver = valueParameterResolver; - } - - @Inject - public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setExternalSignatureResolver(ExternalSignatureResolver externalSignatureResolver) { - this.externalSignatureResolver = externalSignatureResolver; - } - - @Inject - public void setErrorReporter(ErrorReporter errorReporter) { - this.errorReporter = errorReporter; - } - - @Inject - public void setSignatureChecker(MethodSignatureChecker signatureChecker) { - this.signatureChecker = signatureChecker; - } - - @Nullable - SimpleFunctionDescriptor resolveFunctionMutely(@NotNull JavaMethod method, @NotNull ClassOrPackageFragmentDescriptor owner) { - return resolveMethodToFunctionDescriptor(method, owner, false); - } - - @Nullable - private SimpleFunctionDescriptor resolveMethodToFunctionDescriptor( - @NotNull JavaMethod method, - @NotNull ClassOrPackageFragmentDescriptor ownerDescriptor, - boolean record - ) { - if (!DescriptorResolverUtils.isCorrectOwnerForEnumMethod(ownerDescriptor, method)) { - return null; - } - - JavaType returnJavaType = method.getReturnType(); - if (returnJavaType == null) { - // This means that the method is a constructor - return null; - } - - SimpleFunctionDescriptor alreadyResolved = cache.getMethod(method); - if (alreadyResolved != null) { - return alreadyResolved; - } - - SimpleFunctionDescriptorImpl functionDescriptorImpl = new JavaMethodDescriptor( - ownerDescriptor, - annotationResolver.resolveAnnotations(method), - method.getName() - ); - - JavaTypeParameterResolver.Initializer typeParameterInitializer = typeParameterResolver.resolveTypeParameters(functionDescriptorImpl, method); - typeParameterInitializer.initialize(); - List methodTypeParameters = typeParameterInitializer.getDescriptors(); - - TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(methodTypeParameters, functionDescriptorImpl); - - List valueParameters = - valueParameterResolver.resolveValueParameters(functionDescriptorImpl, method, typeVariableResolver); - JetType returnType = makeReturnType(returnJavaType, method, typeVariableResolver); - - - List signatureErrors; - List superFunctions; - ExternalSignatureResolver.AlternativeMethodSignature effectiveSignature; - - if (ownerDescriptor instanceof PackageFragmentDescriptor) { - superFunctions = Collections.emptyList(); - effectiveSignature = externalSignatureResolver - .resolveAlternativeMethodSignature(method, false, returnType, null, valueParameters, methodTypeParameters); - signatureErrors = effectiveSignature.getErrors(); - } - else if (ownerDescriptor instanceof ClassDescriptor) { - ExternalSignatureResolver.PropagatedMethodSignature propagated = externalSignatureResolver - .resolvePropagatedSignature(method, (ClassDescriptor) ownerDescriptor, returnType, null, valueParameters, - methodTypeParameters); - - superFunctions = propagated.getSuperMethods(); - - effectiveSignature = externalSignatureResolver - .resolveAlternativeMethodSignature(method, !superFunctions.isEmpty(), propagated.getReturnType(), - propagated.getReceiverType(), propagated.getValueParameters(), - propagated.getTypeParameters()); - - signatureErrors = new ArrayList(propagated.getErrors()); - signatureErrors.addAll(effectiveSignature.getErrors()); - } - else { - throw new IllegalStateException("Unknown class or package descriptor: " + ownerDescriptor); - } - - functionDescriptorImpl.initialize( - effectiveSignature.getReceiverType(), - DescriptorUtils.getExpectedThisObjectIfNeeded(ownerDescriptor), - effectiveSignature.getTypeParameters(), - effectiveSignature.getValueParameters(), - effectiveSignature.getReturnType(), - Modality.convertFromFlags(method.isAbstract(), !method.isFinal()), - method.getVisibility() - /*TODO what if user annotate it with inline?*/ - ); - - if (record) { - cache.recordMethod(method, functionDescriptorImpl); - } - - signatureChecker.checkSignature(method, record, functionDescriptorImpl, signatureErrors, superFunctions); - - return functionDescriptorImpl; - } - - @NotNull - public Set resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrPackageFragmentDescriptor owner) { - Name methodName = members.getName(); - - Set functionsFromCurrent = new HashSet(); - for (JavaMethod method : members.getMethods()) { - SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(method, owner, true); - if (function != null) { - functionsFromCurrent.add(function); - SimpleFunctionDescriptor samAdapter = resolveSamAdapter(function); - if (samAdapter != null) { - functionsFromCurrent.add(samAdapter); - } - } - } - - if (owner instanceof JavaPackageFragmentDescriptor) { - SamConstructorDescriptor samConstructor = resolveSamConstructor((JavaPackageFragmentDescriptor) owner, members); - if (samConstructor != null) { - functionsFromCurrent.add(samConstructor); - } - } - - Set functions = new HashSet(); - if (owner instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) owner; - - Collection functionsFromSupertypes = getFunctionsFromSupertypes(methodName, classDescriptor); - - functions.addAll(resolveOverrides(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, errorReporter)); - } - - if (isEnumClassObject(owner)) { - for (FunctionDescriptor functionDescriptor : functionsFromCurrent) { - if (!(isEnumValueOfMethod(functionDescriptor) || isEnumValuesMethod(functionDescriptor))) { - functions.add(functionDescriptor); - } - } - } - else { - functions.addAll(functionsFromCurrent); - } - - return functions; - } - - @NotNull - private JetType makeReturnType( - @NotNull JavaType returnType, - @NotNull JavaMethod method, - @NotNull TypeVariableResolver typeVariableResolver - ) { - TypeUsage typeUsage = annotationResolver.hasReadonlyAnnotation(method) && !annotationResolver.hasMutableAnnotation(method) - ? TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT - : TypeUsage.MEMBER_SIGNATURE_COVARIANT; - JetType transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver); - - // Annotation arguments are never null in Java - if (method.getContainingClass().isAnnotationType() || annotationResolver.hasNotNullAnnotation(method)) { - return TypeUtils.makeNotNullable(transformedType); - } - else { - return transformedType; - } - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java deleted file mode 100644 index e96483f9c18..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.name.FqName; - -import javax.inject.Inject; -import java.util.Collection; -import java.util.Set; - -public class JavaMemberResolver { - private JavaClassResolver classResolver; - private JavaFunctionResolver functionResolver; - private JavaPropertyResolver propertyResolver; - private JavaConstructorResolver constructorResolver; - - @Inject - public void setClassResolver(JavaClassResolver classResolver) { - this.classResolver = classResolver; - } - - @Inject - public void setFunctionResolver(JavaFunctionResolver functionResolver) { - this.functionResolver = functionResolver; - } - - @Inject - public void setPropertyResolver(JavaPropertyResolver propertyResolver) { - this.propertyResolver = propertyResolver; - } - - @Inject - public void setConstructorResolver(JavaConstructorResolver constructorResolver) { - this.constructorResolver = constructorResolver; - } - - @Nullable - public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { - return classResolver.resolveClass(qualifiedName, searchRule); - } - - @NotNull - public Set resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrPackageFragmentDescriptor owner) { - return functionResolver.resolveFunctionGroupForClass(members, owner); - } - - @NotNull - public Set resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrPackageFragmentDescriptor ownerDescriptor) { - return propertyResolver.resolveFieldGroup(members, ownerDescriptor); - } - - @NotNull - public Collection resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor classDescriptor) { - return constructorResolver.resolveConstructors(javaClass, classDescriptor); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProviderImpl.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProviderImpl.java deleted file mode 100644 index cebd6a74b3a..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProviderImpl.java +++ /dev/null @@ -1,191 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import com.google.common.collect.Maps; -import com.intellij.util.NullableFunction; -import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.java.JavaClassFinder; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptorImpl; -import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; -import org.jetbrains.jet.lang.resolve.java.scope.JavaFullPackageScope; -import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageFragmentScope; -import org.jetbrains.jet.lang.resolve.java.scope.JavaPurePackageScope; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; -import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; -import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder; -import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass; -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 javax.inject.Inject; -import java.util.*; - -public final class JavaPackageFragmentProviderImpl implements JavaPackageFragmentProvider { - @NotNull - private final Map packageFragments = Maps.newHashMap(); - - private JavaDescriptorResolver javaDescriptorResolver; - private JavaClassFinder javaClassFinder; - private JavaResolverCache cache; - private JavaMemberResolver memberResolver; - - private DeserializedDescriptorResolver deserializedDescriptorResolver; - private KotlinClassFinder kotlinClassFinder; - - private ModuleDescriptor module; - - @Inject - public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) { - this.javaDescriptorResolver = javaDescriptorResolver; - } - - @Inject - public void setKotlinClassFinder(KotlinClassFinder kotlinClassFinder) { - this.kotlinClassFinder = kotlinClassFinder; - } - - @Inject - public void setJavaClassFinder(JavaClassFinder javaClassFinder) { - this.javaClassFinder = javaClassFinder; - } - - @Inject - public void setCache(JavaResolverCache cache) { - this.cache = cache; - } - - @Inject - public void setMemberResolver(@NotNull JavaMemberResolver memberResolver) { - this.memberResolver = memberResolver; - } - - @Inject - public void setDeserializedDescriptorResolver(DeserializedDescriptorResolver deserializedDescriptorResolver) { - this.deserializedDescriptorResolver = deserializedDescriptorResolver; - } - - @Inject - public void setModule(ModuleDescriptor module) { - this.module = module; - } - - @Override - @NotNull - public JavaDescriptorResolver getJavaDescriptorResolver() { - return javaDescriptorResolver; - } - - @NotNull - @Override - public List getPackageFragments(@NotNull FqName fqName) { - return ContainerUtil.createMaybeSingletonList(getPackageFragment(fqName)); - } - - @NotNull - @Override - public Collection getSubPackagesOf(@NotNull FqName fqName) { - JavaPackageFragmentDescriptorImpl packageFragment = getPackageFragment(fqName); - if (packageFragment == null) { - return Collections.emptyList(); - } - - return packageFragment.getMemberScope().getSubPackages(); - } - - @Override - @Nullable - public JavaPackageFragmentDescriptorImpl getPackageFragment(@NotNull final FqName fqName) { - if (packageFragments.containsKey(fqName)) { - return packageFragments.get(fqName); - } - - JavaPackageFragmentDescriptorImpl packageFragment = JavaPackageFragmentDescriptorImpl.create( - this, fqName, new NullableFunction() { - @Override - @Nullable - public JavaPackageFragmentScope fun(JavaPackageFragmentDescriptor packageFragment) { - return createPackageScope(fqName, packageFragment); - } - }); - - packageFragments.put(fqName, packageFragment); - return packageFragment; - } - - @Nullable - private JavaPackageFragmentScope createPackageScope( - @NotNull FqName fqName, - @NotNull PackageFragmentDescriptor packageFragment - ) { - JavaPackage javaPackage = javaClassFinder.findPackage(fqName); - if (javaPackage != null) { - FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName); - KotlinJvmBinaryClass kotlinClass = kotlinClassFinder.findKotlinClass(packageClassFqName); - - if (kotlinClass != null) { - JetScope kotlinPackageScope = deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinClass); - if (kotlinPackageScope != null) { - return new JavaFullPackageScope(packageFragment, kotlinPackageScope, - new JavaPurePackageScope(packageFragment, javaPackage, fqName, memberResolver, - /* includeCompiledKotlinClasses = */ false)); - } - } - - return new JavaPurePackageScope(packageFragment, javaPackage, fqName, memberResolver, - /* includeCompiledKotlinClasses = */ true); - } - - JavaClass javaClass = javaClassFinder.findClass(fqName); - if (javaClass != null && DescriptorResolverUtils.isJavaClassVisibleAsPackage(javaClass)) { - return new JavaClassStaticMembersScope(packageFragment, javaClass, memberResolver); - } - return null; - } - - @Override - @NotNull - public Collection getClassNamesInPackage(@NotNull FqName packageName) { - JavaPackage javaPackage = javaClassFinder.findPackage(packageName); - if (javaPackage == null) return Collections.emptyList(); - - Collection classes = DescriptorResolverUtils.getClassesInPackage(javaPackage); - List result = new ArrayList(classes.size()); - for (JavaClass javaClass : classes) { - if (!DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass)) { - result.add(javaClass.getName()); - } - } - - return result; - } - - @Override - @NotNull - public ModuleDescriptor getModule() { - return module; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java deleted file mode 100644 index 803ce087fc3..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptor; -import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers; -import org.jetbrains.jet.lang.resolve.java.structure.JavaField; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; - -import javax.inject.Inject; -import java.util.*; - -import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClassObject; -import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.resolveOverrides; - -public final class JavaPropertyResolver { - private JavaTypeTransformer typeTransformer; - private JavaResolverCache cache; - private JavaAnnotationResolver annotationResolver; - private ExternalSignatureResolver externalSignatureResolver; - private ErrorReporter errorReporter; - - @Inject - public void setTypeTransformer(@NotNull JavaTypeTransformer javaTypeTransformer) { - this.typeTransformer = javaTypeTransformer; - } - - @Inject - public void setCache(JavaResolverCache cache) { - this.cache = cache; - } - - @Inject - public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setExternalSignatureResolver(ExternalSignatureResolver externalSignatureResolver) { - this.externalSignatureResolver = externalSignatureResolver; - } - - @Inject - public void setErrorReporter(ErrorReporter errorReporter) { - this.errorReporter = errorReporter; - } - - @NotNull - public Set resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrPackageFragmentDescriptor owner) { - if (isEnumClassObject(owner)) { - return Collections.emptySet(); - } - - Name propertyName = members.getName(); - - List fields = members.getFields(); - - Set propertiesFromCurrent = new HashSet(1); - assert fields.size() <= 1; - if (fields.size() == 1) { - JavaField field = fields.iterator().next(); - if (!field.isEnumEntry()) { - propertiesFromCurrent.add(resolveProperty(owner, propertyName, field)); - } - } - - Set properties = new HashSet(); - if (owner instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) owner; - - Collection propertiesFromSupertypes = getPropertiesFromSupertypes(propertyName, classDescriptor); - - properties.addAll(resolveOverrides(propertyName, propertiesFromSupertypes, propertiesFromCurrent, classDescriptor, - errorReporter)); - } - - properties.addAll(propertiesFromCurrent); - - return new HashSet(properties); - } - - @NotNull - private PropertyDescriptor resolveProperty(@NotNull ClassOrPackageFragmentDescriptor owner, @NotNull Name name, @NotNull JavaField field) { - assert !field.isEnumEntry() : "Enum entries are resolved into classes, not into properties: " + name; - - boolean isVar = !field.isFinal(); - - PropertyDescriptorImpl propertyDescriptor = - new JavaPropertyDescriptor(owner, annotationResolver.resolveAnnotations(field), field.getVisibility(), isVar, name); - propertyDescriptor.initialize(null, null); - - TypeVariableResolver typeVariableResolver = - new TypeVariableResolverImpl(Collections.emptyList(), propertyDescriptor); - - JetType propertyType = getPropertyType(field, typeVariableResolver); - - ExternalSignatureResolver.AlternativeFieldSignature effectiveSignature = - externalSignatureResolver.resolveAlternativeFieldSignature(field, propertyType, isVar); - List signatureErrors = effectiveSignature.getErrors(); - if (!signatureErrors.isEmpty()) { - externalSignatureResolver.reportSignatureErrors(propertyDescriptor, signatureErrors); - } - - propertyDescriptor.setType( - effectiveSignature.getReturnType(), - Collections.emptyList(), - DescriptorUtils.getExpectedThisObjectIfNeeded(owner), - (JetType) null - ); - - cache.recordField(field, propertyDescriptor); - - return propertyDescriptor; - } - - @NotNull - private JetType getPropertyType(@NotNull JavaField field, @NotNull TypeVariableResolver typeVariableResolver) { - JetType propertyType = typeTransformer.transformToType(field.getType(), typeVariableResolver); - - if (annotationResolver.hasNotNullAnnotation(field) || isStaticFinalField(field) /* TODO: WTF? */) { - return TypeUtils.makeNotNullable(propertyType); - } - - return propertyType; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java deleted file mode 100644 index 17ac782d025..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType; -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 javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; - -public final class JavaSupertypeResolver { - - private JavaTypeTransformer typeTransformer; - private JavaClassResolver classResolver; - - @Inject - public void setTypeTransformer(JavaTypeTransformer typeTransformer) { - this.typeTransformer = typeTransformer; - } - - @Inject - public void setClassResolver(JavaClassResolver classResolver) { - this.classResolver = classResolver; - } - - @NotNull - public Collection getSupertypes( - @NotNull ClassDescriptor classDescriptor, - @NotNull JavaClass javaClass, - @NotNull List typeParameters - ) { - TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(typeParameters, classDescriptor); - - List result = transformSupertypeList(javaClass.getSupertypes(), typeVariableResolver); - - return result.isEmpty() ? Collections.singletonList(getDefaultSupertype(javaClass)) : result; - } - - @NotNull - private JetType getDefaultSupertype(@NotNull JavaClass javaClass) { - if (OBJECT_FQ_NAME.equals(javaClass.getFqName()) || javaClass.isAnnotationType()) { - return KotlinBuiltIns.getInstance().getAnyType(); - } - else { - ClassDescriptor object = classResolver.resolveClass(OBJECT_FQ_NAME, IGNORE_KOTLIN_SOURCES); - if (object != null) { - return object.getDefaultType(); - } - else { - //TODO: hack here - return KotlinBuiltIns.getInstance().getAnyType(); - // throw new IllegalStateException("Could not resolve java.lang.Object"); - } - } - } - - @NotNull - private List transformSupertypeList( - @NotNull Collection supertypes, - @NotNull TypeVariableResolver typeVariableResolver - ) { - List result = new ArrayList(supertypes.size()); - for (JavaClassifierType type : supertypes) { - JetType transformed = typeTransformer.transformToType(type, TypeUsage.SUPERTYPE, typeVariableResolver); - if (transformed.isError()) { - // TODO: report INCOMPLETE_HIERARCHY - } - else { - result.add(TypeUtils.makeNotNullable(transformed)); - } - } - return result; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java deleted file mode 100644 index 5c4d910dadf..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType; -import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter; -import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameterListOwner; -import org.jetbrains.jet.lang.types.Variance; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; - -import javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Iterator; -import java.util.List; - -public final class JavaTypeParameterResolver { - @NotNull - private JavaTypeTransformer typeTransformer; - - @Inject - public void setTypeTransformer(@NotNull JavaTypeTransformer javaTypeTransformer) { - this.typeTransformer = javaTypeTransformer; - } - - @NotNull - public Initializer resolveTypeParameters( - @NotNull DeclarationDescriptor ownerDescriptor, - @NotNull JavaTypeParameterListOwner typeParameterListOwner - ) { - Initializer result = new Initializer(ownerDescriptor); - for (JavaTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) { - result.addTypeParameter(typeParameter); - } - return result; - } - - public class Initializer { - private final DeclarationDescriptor owner; - private final List descriptors = new ArrayList(); - private final List javaTypeParameters = new ArrayList(); - - private Initializer(@NotNull DeclarationDescriptor owner) { - this.owner = owner; - } - - private void addTypeParameter(@NotNull JavaTypeParameter typeParameter) { - TypeParameterDescriptorImpl descriptor = TypeParameterDescriptorImpl.createForFurtherModification( - owner, - Annotations.EMPTY, // TODO - false, - Variance.INVARIANT, - typeParameter.getName(), - typeParameter.getIndex() - ); - - descriptors.add(descriptor); - javaTypeParameters.add(typeParameter); - } - - @NotNull - public List getDescriptors() { - return descriptors; - } - - public void initialize() { - TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(getDescriptors(), owner); - - Iterator descriptorIterator = descriptors.iterator(); - Iterator typeParameterIterator = javaTypeParameters.iterator(); - - while (descriptorIterator.hasNext()) { - TypeParameterDescriptorImpl descriptor = (TypeParameterDescriptorImpl) descriptorIterator.next(); - Collection upperBounds = typeParameterIterator.next().getUpperBounds(); - - if (upperBounds.isEmpty()) { - descriptor.addUpperBound(KotlinBuiltIns.getInstance().getDefaultBound()); - } - else { - for (JavaClassifierType upperBound : upperBounds) { - descriptor.addUpperBound(typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver)); - } - } - descriptor.setInitialized(); - } - } - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java deleted file mode 100644 index 6fee605ed86..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java +++ /dev/null @@ -1,278 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.java.structure.*; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; - -import javax.inject.Inject; -import java.util.*; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; -import static org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage.*; -import static org.jetbrains.jet.lang.types.Variance.*; - -public class JavaTypeTransformer { - private JavaClassResolver classResolver; - - @Inject - public void setClassResolver(JavaClassResolver classResolver) { - this.classResolver = classResolver; - } - - @NotNull - private TypeProjection transformToTypeProjection( - @NotNull JavaType type, - @NotNull TypeParameterDescriptor typeParameterDescriptor, - @NotNull TypeVariableResolver typeVariableResolver, - @NotNull TypeUsage howThisTypeIsUsed - ) { - if (!(type instanceof JavaWildcardType)) { - return new TypeProjectionImpl(transformToType(type, howThisTypeIsUsed, typeVariableResolver)); - } - - JavaWildcardType wildcardType = (JavaWildcardType) type; - JavaType bound = wildcardType.getBound(); - if (bound == null) { - return SubstitutionUtils.makeStarProjection(typeParameterDescriptor); - } - - Variance variance = wildcardType.isExtends() ? OUT_VARIANCE : IN_VARIANCE; - - return new TypeProjectionImpl(variance, transformToType(bound, UPPER_BOUND, typeVariableResolver)); - } - - @NotNull - public JetType transformToType(@NotNull JavaType type, @NotNull TypeVariableResolver typeVariableResolver) { - return transformToType(type, TypeUsage.MEMBER_SIGNATURE_INVARIANT, typeVariableResolver); - } - - @NotNull - public JetType transformToType( - @NotNull JavaType type, - @NotNull TypeUsage howThisTypeIsUsed, - @NotNull TypeVariableResolver typeVariableResolver - ) { - if (type instanceof JavaClassifierType) { - JavaClassifierType classifierType = (JavaClassifierType) type; - return transformClassifierType(classifierType, howThisTypeIsUsed, typeVariableResolver); - } - else if (type instanceof JavaPrimitiveType) { - String canonicalText = ((JavaPrimitiveType) type).getCanonicalText(); - JetType jetType = JavaToKotlinClassMap.getInstance().mapPrimitiveKotlinClass(canonicalText); - assert jetType != null : "Primitive type is not found: " + canonicalText; - return jetType; - } - else if (type instanceof JavaArrayType) { - return transformArrayType((JavaArrayType) type, howThisTypeIsUsed, typeVariableResolver, false); - } - else { - throw new UnsupportedOperationException("Unsupported type: " + type); // TODO - } - } - - @NotNull - private JetType transformClassifierType( - @NotNull JavaClassifierType classifierType, - @NotNull TypeUsage howThisTypeIsUsed, - @NotNull TypeVariableResolver typeVariableResolver - ) { - JavaClassifier javaClassifier = classifierType.getClassifier(); - if (javaClassifier instanceof JavaTypeParameter) { - return transformTypeParameter((JavaTypeParameter) javaClassifier, classifierType, howThisTypeIsUsed, typeVariableResolver); - } - else { - return transformClassType(javaClassifier, classifierType, howThisTypeIsUsed, typeVariableResolver); - } - } - - @NotNull - private JetType transformTypeParameter( - @NotNull JavaTypeParameter typeParameter, - @NotNull JavaClassifierType classifierType, - @NotNull TypeUsage howThisTypeIsUsed, - @NotNull TypeVariableResolver typeVariableResolver - ) { - // In Java: ArrayList - // In Kotlin: ArrayList, not ArrayList - // nullability will be taken care of in individual member signatures - boolean nullable = !EnumSet.of(TYPE_ARGUMENT, UPPER_BOUND, SUPERTYPE_ARGUMENT).contains(howThisTypeIsUsed); - - JavaTypeParameterListOwner owner = typeParameter.getOwner(); - if (owner instanceof JavaMethod && ((JavaMethod) owner).isConstructor()) { - Set supertypesJet = new HashSet(); - for (JavaClassifierType supertype : typeParameter.getUpperBounds()) { - supertypesJet.add(transformToType(supertype, UPPER_BOUND, typeVariableResolver)); - } - JetType intersection = TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet); - if (intersection == null) { - return createErrorClassifierType(classifierType, nullable); - } - return intersection; - } - - TypeParameterDescriptor descriptor = typeVariableResolver.getTypeVariable(typeParameter.getName()); - if (descriptor == null) return createErrorClassifierType(classifierType, nullable); - - return TypeUtils.makeNullableIfNeeded(descriptor.getDefaultType(), nullable); - } - - @NotNull - private JetType transformClassType( - @Nullable JavaClassifier javaClassifier, - @NotNull JavaClassifierType classifierType, - @NotNull TypeUsage howThisTypeIsUsed, - @NotNull TypeVariableResolver typeVariableResolver - ) { - // 'L extends List' in Java is a List in Kotlin, not a List - boolean nullable = !EnumSet.of(TYPE_ARGUMENT, SUPERTYPE_ARGUMENT, SUPERTYPE).contains(howThisTypeIsUsed); - - if (javaClassifier == null) return createErrorClassifierType(classifierType, nullable); - - FqName fqName = ((JavaClass) javaClassifier).getFqName(); - assert fqName != null : "Class type should have a FQ name: " + javaClassifier; - - ClassDescriptor classData = JavaToKotlinClassMap.getInstance().mapKotlinClass(fqName, howThisTypeIsUsed); - - if (classData == null) { - classData = classResolver.resolveClass(fqName, INCLUDE_KOTLIN_SOURCES); - } - if (classData == null) { - return createErrorClassifierType(classifierType, nullable); - } - - List arguments = new ArrayList(); - List parameters = classData.getTypeConstructor().getParameters(); - if (isRaw(classifierType, !parameters.isEmpty())) { - for (TypeParameterDescriptor parameter : parameters) { - // not making a star projection because of this case: - // Java: - // class C {} - // The upper bound is raw here, and we can't compute the projection: it would be infinite: - // C<*> = C>> - // this way we loose some type information, even when the case is not so bad, but it doesn't seem to matter - - // projections are not allowed in immediate arguments of supertypes - Variance projectionKind = parameter.getVariance() == OUT_VARIANCE || howThisTypeIsUsed == SUPERTYPE - ? INVARIANT - : OUT_VARIANCE; - arguments.add(new TypeProjectionImpl(projectionKind, KotlinBuiltIns.getInstance().getNullableAnyType())); - } - } - else { - List javaTypeArguments = classifierType.getTypeArguments(); - - if (parameters.size() != javaTypeArguments.size()) { - // Most of the time this means there is an error in the Java code - for (TypeParameterDescriptor parameter : parameters) { - arguments.add(new TypeProjectionImpl(ErrorUtils.createErrorType(parameter.getName().asString()))); - } - } - else { - for (int i = 0, size = javaTypeArguments.size(); i < size; i++) { - JavaType typeArgument = javaTypeArguments.get(i); - TypeParameterDescriptor typeParameterDescriptor = parameters.get(i); - - TypeUsage howTheProjectionIsUsed = howThisTypeIsUsed == SUPERTYPE ? SUPERTYPE_ARGUMENT : TYPE_ARGUMENT; - TypeProjection typeProjection = - transformToTypeProjection(typeArgument, typeParameterDescriptor, typeVariableResolver, howTheProjectionIsUsed); - - if (typeProjection.getProjectionKind() == typeParameterDescriptor.getVariance()) { - // remove redundant 'out' and 'in' - arguments.add(new TypeProjectionImpl(INVARIANT, typeProjection.getType())); - } - else { - arguments.add(typeProjection); - } - } - } - } - - return new JetTypeImpl( - Annotations.EMPTY, - classData.getTypeConstructor(), - nullable, - arguments, - classData.getMemberScope(arguments)); - } - - @NotNull - private static JetType createErrorClassifierType(JavaClassifierType classifierType, boolean nullable) { - return TypeUtils.makeNullableAsSpecified( - ErrorUtils.createErrorType("Unresolved java classifier: " + classifierType.getPresentableText()), - nullable - ); - } - - @NotNull - private JetType transformArrayType( - @NotNull JavaArrayType arrayType, - @NotNull TypeUsage howThisTypeIsUsed, - @NotNull TypeVariableResolver typeVariableResolver, - boolean vararg - ) { - JavaType componentType = arrayType.getComponentType(); - if (componentType instanceof JavaPrimitiveType) { - JetType jetType = JavaToKotlinClassMap.getInstance().mapPrimitiveKotlinClass( - "[" + ((JavaPrimitiveType) componentType).getCanonicalText()); - if (jetType != null) { - return TypeUtils.makeNullable(jetType); - } - } - - Variance projectionKind = arrayElementTypeProjectionKind(howThisTypeIsUsed, vararg); - TypeUsage howArgumentTypeIsUsed = vararg ? MEMBER_SIGNATURE_CONTRAVARIANT : TYPE_ARGUMENT; - - JetType type = transformToType(componentType, howArgumentTypeIsUsed, typeVariableResolver); - return TypeUtils.makeNullable(KotlinBuiltIns.getInstance().getArrayType(projectionKind, type)); - } - - @NotNull - private static Variance arrayElementTypeProjectionKind(@NotNull TypeUsage howThisTypeIsUsed, boolean vararg) { - if (howThisTypeIsUsed == MEMBER_SIGNATURE_CONTRAVARIANT && !vararg) { - return OUT_VARIANCE; - } - else { - return INVARIANT; - } - } - - @NotNull - public JetType transformVarargType( - @NotNull JavaArrayType type, - @NotNull TypeUsage howThisTypeIsUsed, - @NotNull TypeVariableResolver typeVariableResolver - ) { - return transformArrayType(type, howThisTypeIsUsed, typeVariableResolver, true); - } - - private static boolean isRaw(@NotNull JavaClassifierType classifierType, boolean argumentsExpected) { - // The second option is needed because sometimes we get weird versions of JDK classes in the class path, - // such as collections with no generics, so the Java types are not raw, formally, but they don't match with - // their Kotlin analogs, so we treat them as raw to avoid exceptions - return classifierType.isRaw() || argumentsExpected && classifierType.getTypeArguments().isEmpty(); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java deleted file mode 100644 index 7c18c1da622..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; -import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType; -import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; -import org.jetbrains.jet.lang.resolve.java.structure.JavaType; -import org.jetbrains.jet.lang.resolve.java.structure.JavaValueParameter; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; - -import javax.inject.Inject; -import java.util.ArrayList; -import java.util.List; - -public final class JavaValueParameterResolver { - private JavaAnnotationResolver annotationResolver; - private JavaTypeTransformer typeTransformer; - - @Inject - public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setTypeTransformer(JavaTypeTransformer typeTransformer) { - this.typeTransformer = typeTransformer; - } - - @NotNull - private ValueParameterDescriptor resolveValueParameter( - @NotNull DeclarationDescriptor containingDeclaration, - int i, - @NotNull JavaValueParameter parameter, - @NotNull TypeVariableResolver typeVariableResolver - ) { - TypeUsage typeUsage = annotationResolver.hasMutableAnnotation(parameter) - ? TypeUsage.MEMBER_SIGNATURE_COVARIANT - : TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT; - - JavaType parameterType = parameter.getType(); - - JetType varargElementType; - JetType outType; - if (parameter.isVararg()) { - // TODO: test this code - assert parameterType instanceof JavaArrayType : "Vararg parameter should be an array: " + parameterType; - JetType arrayType = typeTransformer.transformVarargType(((JavaArrayType) parameterType), typeUsage, typeVariableResolver); - - outType = TypeUtils.makeNotNullable(arrayType); - varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(outType); - } - else { - JetType transformedType = typeTransformer.transformToType(parameterType, typeUsage, typeVariableResolver); - if (transformedType.isNullable() && annotationResolver.hasNotNullAnnotation(parameter)) { - transformedType = TypeUtils.makeNotNullable(transformedType); - } - - outType = transformedType; - varargElementType = null; - } - - return new ValueParameterDescriptorImpl( - containingDeclaration, - i, - annotationResolver.resolveAnnotations(parameter), - getParameterName(i, parameter), // TODO: must be very slow, make it lazy? - outType, - false, - varargElementType - ); - } - - @NotNull - private static Name getParameterName(int number, @NotNull JavaValueParameter parameter) { - Name psiParameterName = parameter.getName(); - return psiParameterName != null ? psiParameterName : Name.identifier("p" + number); - } - - @NotNull - public List resolveValueParameters( - @NotNull DeclarationDescriptor container, - @NotNull JavaMethod method, - @NotNull TypeVariableResolver typeVariableResolver - ) { - List parameters = method.getValueParameters(); - List result = new ArrayList(parameters.size()); - for (int i = 0, size = parameters.size(); i < size; i++) { - result.add(resolveValueParameter(container, i, parameters.get(i), typeVariableResolver)); - } - return result; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PostponedTasks.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PostponedTasks.java deleted file mode 100644 index 6242c08beb0..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PostponedTasks.java +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; - -import java.util.ArrayList; -import java.util.List; - -public final class PostponedTasks { - - @NotNull - private final List tasks = new ArrayList(); - - public void addTask(@NotNull Runnable runnable) { - tasks.add(runnable); - } - - public void performTasks() { - for (Runnable task : tasks) { - task.run(); - } - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressChecker.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressChecker.java deleted file mode 100644 index c33a634a868..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ProgressChecker.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; - -import java.util.Iterator; -import java.util.ServiceLoader; - -public abstract class ProgressChecker { - private static ProgressChecker instance; - - @NotNull - public static ProgressChecker getInstance() { - if (instance == null) { - Iterator iterator = - ServiceLoader.load(ProgressChecker.class, ProgressChecker.class.getClassLoader()).iterator(); - assert iterator.hasNext() : "No service found: " + ProgressChecker.class.getName(); - instance = iterator.next(); - } - return instance; - } - - public abstract void checkCanceled(); -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java deleted file mode 100644 index 9ee8600b1a4..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.resolve.name.Name; - -public interface TypeVariableResolver { - TypeVariableResolver EMPTY = new TypeVariableResolver() { - @Nullable - @Override - public TypeParameterDescriptor getTypeVariable(@NotNull Name name) { - return null; - } - }; - - @Nullable - TypeParameterDescriptor getTypeVariable(@NotNull Name name); -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java deleted file mode 100644 index a94fa90b384..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright 2010-2013 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.java.resolver; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.List; - -/* package */ class TypeVariableResolverImpl implements TypeVariableResolver { - @NotNull - private final List typeParameters; - @NotNull - private final DeclarationDescriptor owner; - - public TypeVariableResolverImpl(@NotNull List typeParameters, @NotNull DeclarationDescriptor owner) { - this.typeParameters = typeParameters; - this.owner = owner; - - assert parametersBelongToOwner() : "Type parameters should belong to owner: " + owner + "; " + typeParameters; - } - - private boolean parametersBelongToOwner() { - for (TypeParameterDescriptor typeParameter : typeParameters) { - if (typeParameter.getContainingDeclaration() != owner) { - return false; - } - } - return true; - } - - @Nullable - @Override - public TypeParameterDescriptor getTypeVariable(@NotNull Name name) { - return getTypeVariable(name, typeParameters, owner); - } - - @Nullable - private static TypeParameterDescriptor getTypeVariable( - @NotNull Name name, - @NotNull List typeParameters, - @NotNull DeclarationDescriptor owner - ) { - for (TypeParameterDescriptor typeParameter : typeParameters) { - if (typeParameter.getName().equals(name)) { - return typeParameter; - } - } - - DeclarationDescriptor container = owner.getContainingDeclaration(); - if (container instanceof ClassDescriptor) { - return getTypeVariable(name, ((ClassDescriptor) container).getTypeConstructor().getParameters(), container); - } - - return null; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java deleted file mode 100644 index 368a7a6fa14..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java +++ /dev/null @@ -1,165 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.TestOnly; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl; -import org.jetbrains.jet.utils.Printer; - -import java.util.*; - -public abstract class JavaBaseScope extends JetScopeImpl { - @NotNull - protected final JavaMemberResolver memberResolver; - @NotNull - protected final MembersProvider membersProvider; - @NotNull - private final Map> functionDescriptors = new HashMap>(); - @NotNull - private final Map> propertyDescriptors = new HashMap>(); - @Nullable - private Collection allDescriptors = null; - @NotNull - protected final ClassOrPackageFragmentDescriptor descriptor; - - private Collection innerClasses = null; - - - protected JavaBaseScope( - @NotNull ClassOrPackageFragmentDescriptor descriptor, - @NotNull JavaMemberResolver memberResolver, - @NotNull MembersProvider membersProvider - ) { - this.memberResolver = memberResolver; - this.membersProvider = membersProvider; - this.descriptor = descriptor; - } - - @NotNull - @Override - public DeclarationDescriptor getContainingDeclaration() { - return descriptor; - } - - @NotNull - @Override - public Collection getProperties(@NotNull Name name) { - Set cached = propertyDescriptors.get(name); - if (cached != null) return cached; - - if (allDescriptorsComputed()) { - return Collections.emptySet(); - } - - Set computedDescriptors = computePropertyDescriptors(name); - propertyDescriptors.put(name, computedDescriptors); - return computedDescriptors; - } - - @NotNull - private Set computePropertyDescriptors(@NotNull Name name) { - NamedMembers members = membersProvider.get(name); - if (members == null) { - return Collections.emptySet(); - } - return memberResolver.resolveFieldGroup(members, descriptor); - } - - @NotNull - @Override - public Collection getFunctions(@NotNull Name name) { - Set cached = functionDescriptors.get(name); - if (cached != null) return cached; - - if (allDescriptorsComputed()) { - return Collections.emptySet(); - } - - Set computedDescriptors = computeFunctionDescriptor(name); - functionDescriptors.put(name, computedDescriptors); - return computedDescriptors; - } - - @NotNull - protected abstract Set computeFunctionDescriptor(@NotNull Name name); - - @NotNull - @Override - public Collection getAllDescriptors() { - if (allDescriptorsComputed()) { - return allDescriptors; - } - - allDescriptors = computeAllDescriptors(); - - return allDescriptors; - } - - private boolean allDescriptorsComputed() { - return allDescriptors != null; - } - - @NotNull - protected Collection computeAllDescriptors() { - Collection result = new HashSet(); - result.addAll(computeFieldAndFunctionDescriptors()); - result.addAll(getInnerClasses()); - return result; - } - - @NotNull - protected abstract Collection computeInnerClasses(); - - @NotNull - private Collection computeFieldAndFunctionDescriptors() { - Collection result = new ArrayList(); - for (NamedMembers members : membersProvider.allMembers()) { - Name name = members.getName(); - ProgressChecker.getInstance().checkCanceled(); - result.addAll(getFunctions(name)); - ProgressChecker.getInstance().checkCanceled(); - result.addAll(getProperties(name)); - } - return result; - } - - @NotNull - protected Collection getInnerClasses() { - if (innerClasses == null) { - innerClasses = computeInnerClasses(); - } - return innerClasses; - } - - @TestOnly - @Override - public void printScopeStructure(@NotNull Printer p) { - p.println(getClass().getSimpleName(), " {"); - p.pushIndent(); - - p.println("descriptor = ", descriptor); - - p.popIndent(); - p.println("}"); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java deleted file mode 100644 index d8eee2edca4..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.name.LabelName; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.*; - -public abstract class JavaClassMembersScope extends JavaBaseScope { - private Map innerClassesMap = null; - - protected JavaClassMembersScope( - @NotNull ClassOrPackageFragmentDescriptor descriptor, - @NotNull MembersProvider membersProvider, - @NotNull JavaMemberResolver memberResolver - ) { - super(descriptor, memberResolver, membersProvider); - } - - @NotNull - @Override - public Collection getDeclarationsByLabel(@NotNull LabelName labelName) { - throw new UnsupportedOperationException(); // TODO - } - - - @NotNull - @Override - protected Set computeFunctionDescriptor(@NotNull Name name) { - NamedMembers members = membersProvider.get(name); - if (members == null) { - return Collections.emptySet(); - } - return memberResolver.resolveFunctionGroupForClass(members, descriptor); - } - - @Override - public ClassifierDescriptor getClassifier(@NotNull Name name) { - if (innerClassesMap == null) { - Collection innerClasses = getInnerClasses(); - innerClassesMap = new HashMap(); - for (ClassDescriptor innerClass : innerClasses) { - innerClassesMap.put(innerClass.getName(), innerClass); - } - } - return innerClassesMap.get(name); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java deleted file mode 100644 index 183069f250d..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import jet.Function0; -import jet.Function1; -import kotlin.KotlinPackage; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.EnumEntrySyntheticClassDescriptor; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaField; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.storage.LockBasedStorageManager; -import org.jetbrains.jet.storage.NotNullLazyValue; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClass; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; - -public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope { - @NotNull - private final ClassDescriptor descriptor; - @NotNull - private final JavaClass javaClass; - - public JavaClassNonStaticMembersScope( - @NotNull ClassDescriptor descriptor, - @NotNull JavaClass javaClass, - @NotNull JavaMemberResolver memberResolver - ) { - super(descriptor, MembersProvider.forClass(javaClass, false), memberResolver); - this.descriptor = descriptor; - this.javaClass = javaClass; - } - - @NotNull - public Collection getConstructors() { - return memberResolver.resolveConstructors(javaClass, descriptor); - } - - @NotNull - @Override - protected Collection computeInnerClasses() { - Collection innerClasses = javaClass.getInnerClasses(); - List result = new ArrayList(innerClasses.size()); - for (JavaClass innerClass : innerClasses) { - result.add(resolveInnerClass(innerClass)); - } - - if (isEnumClass(descriptor)) { - result.addAll(computeEnumEntries()); - } - - return result; - } - - private Collection computeEnumEntries() { - List result = new ArrayList(); - - final Collection enumNonStaticMembers = MembersProvider.forClass(javaClass, true).allMembers(); - - NotNullLazyValue> enumMemberNames = - LockBasedStorageManager.NO_LOCKS.createLazyValue(new Function0>() { - @Override - public Collection invoke() { - return KotlinPackage.map(enumNonStaticMembers, new Function1() { - @Override - public Name invoke(@NotNull NamedMembers members) { - return members.getName(); - } - }); - } - }); - - for (NamedMembers members : enumNonStaticMembers) { - for (JavaField field : members.getFields()) { - if (field.isEnumEntry()) { - EnumEntrySyntheticClassDescriptor enumEntry = EnumEntrySyntheticClassDescriptor - .create(LockBasedStorageManager.NO_LOCKS, descriptor, members.getName(), enumMemberNames); - result.add(enumEntry); - break; - } - } - } - - return result; - } - - @NotNull - private ClassDescriptor resolveInnerClass(@NotNull JavaClass innerClass) { - FqName fqName = innerClass.getFqName(); - assert fqName != null : "Inner class has no qualified name: " + innerClass; - ClassDescriptor classDescriptor = memberResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES); - assert classDescriptor != null : "Couldn't resolve inner class " + fqName; - return classDescriptor; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java deleted file mode 100644 index 87063d0824d..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import com.google.common.collect.Lists; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -import org.jetbrains.jet.lang.descriptors.Visibility; -import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.name.FqName; - -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -public final class JavaClassStaticMembersScope extends JavaClassMembersScope implements JavaPackageFragmentScope { - @NotNull - private final JavaClass javaClass; - - public JavaClassStaticMembersScope( - @NotNull PackageFragmentDescriptor descriptor, - @NotNull JavaClass javaClass, - @NotNull JavaMemberResolver memberResolver - ) { - super(descriptor, MembersProvider.forClass(javaClass, true), memberResolver); - this.javaClass = javaClass; - } - - @NotNull - @Override - protected Collection computeInnerClasses() { - return Collections.emptyList(); - } - - @Override - @NotNull - public Collection getSubPackages() { - List result = Lists.newArrayList(); - for (JavaClass nested : javaClass.getInnerClasses()) { - if (DescriptorResolverUtils.isJavaClassVisibleAsPackage(nested)) { - result.add(nested.getFqName()); - } - } - return result; - } - -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaEnumClassObjectScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaEnumClassObjectScope.java deleted file mode 100644 index f0373a35595..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaEnumClassObjectScope.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; - -import java.util.Collection; -import java.util.Collections; - -public class JavaEnumClassObjectScope extends JavaClassMembersScope { - public JavaEnumClassObjectScope( - @NotNull ClassOrPackageFragmentDescriptor descriptor, - @NotNull JavaClass javaClass, - @NotNull JavaMemberResolver memberResolver - ) { - super(descriptor, MembersProvider.forClass(javaClass, true), memberResolver); - } - - @NotNull - @Override - protected Collection computeInnerClasses() { - return Collections.emptySet(); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaFullPackageScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaFullPackageScope.java deleted file mode 100644 index 9d12ed6f3f0..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaFullPackageScope.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.scopes.ChainedScope; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; - -import java.util.Collection; - -public class JavaFullPackageScope extends ChainedScope implements JavaPackageFragmentScope { - private final JavaPurePackageScope purePackageScope; - - public JavaFullPackageScope( - @NotNull PackageFragmentDescriptor packageFragment, - @NotNull JetScope kotlinPackageScope, - @NotNull JavaPurePackageScope purePackageScope - ) { - super(packageFragment, "JavaFullPackageScope", kotlinPackageScope, purePackageScope); - this.purePackageScope = purePackageScope; - } - - @Override - public Collection getSubPackages() { - return purePackageScope.getSubPackages(); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageFragmentScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageFragmentScope.java deleted file mode 100644 index 244d1ef3dc6..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageFragmentScope.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; - -import java.util.Collection; - -public interface JavaPackageFragmentScope extends JetScope { - Collection getSubPackages(); -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPurePackageScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPurePackageScope.java deleted file mode 100644 index b2f0cefadfa..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPurePackageScope.java +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import com.google.common.collect.Lists; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor; -import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.*; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; - -public final class JavaPurePackageScope extends JavaBaseScope implements JavaPackageFragmentScope { - @NotNull - private final JavaPackage javaPackage; - @NotNull - private final FqName packageFQN; - private final boolean includeCompiledKotlinClasses; - - private List subPackages = null; - private final Object subPackagesLock = new Object(); - - public JavaPurePackageScope( - @NotNull PackageFragmentDescriptor descriptor, - @NotNull JavaPackage javaPackage, - @NotNull FqName packageFQN, - @NotNull JavaMemberResolver memberResolver, - boolean includeCompiledKotlinClasses - ) { - super(descriptor, memberResolver, MembersProvider.forPackage(javaPackage)); - this.javaPackage = javaPackage; - this.packageFQN = packageFQN; - this.includeCompiledKotlinClasses = includeCompiledKotlinClasses; - } - - @Override - public ClassifierDescriptor getClassifier(@NotNull Name name) { - return memberResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES); - } - - @NotNull - @Override - protected Collection computeAllDescriptors() { - Collection result = super.computeAllDescriptors(); - result.addAll(computeAllPackageDeclarations()); - return result; - } - - @NotNull - private Collection computeAllPackageDeclarations() { - Collection result = new HashSet(); - - for (JavaClass javaClass : DescriptorResolverUtils.getClassesInPackage(javaPackage)) { - if (DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass)) continue; - if (!includeCompiledKotlinClasses && DescriptorResolverUtils.isCompiledKotlinClass(javaClass)) continue; - - if (javaClass.getOriginKind() == JavaClass.OriginKind.KOTLIN_LIGHT_CLASS) continue; - - if (javaClass.getVisibility() == Visibilities.PRIVATE) continue; - - ProgressChecker.getInstance().checkCanceled(); - - FqName fqName = javaClass.getFqName(); - if (fqName == null) continue; - - ClassDescriptor classDescriptor = memberResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES); - if (classDescriptor != null) { - result.add(classDescriptor); - } - } - - return result; - } - - @Override - @NotNull - protected Set computeFunctionDescriptor(@NotNull Name name) { - NamedMembers members = membersProvider.get(name); - if (members == null) { - return Collections.emptySet(); - } - SamConstructorDescriptor samConstructor = JavaFunctionResolver.resolveSamConstructor((JavaPackageFragmentDescriptor) descriptor, members); - if (samConstructor == null) { - return Collections.emptySet(); - } - return Collections.singleton(samConstructor); - } - - @NotNull - @Override - protected Collection computeInnerClasses() { - return Collections.emptyList(); - } - - @Override - @NotNull - public Collection getSubPackages() { - synchronized (subPackagesLock) { - if (subPackages == null) { - subPackages = Lists.newArrayList(); // Initializing with empty list to avoid infinite recursion - - subPackages = computeSubPackages(); - } - return subPackages; - } - } - - @NotNull - private List computeSubPackages() { - List result = Lists.newArrayList(); - for (JavaPackage subPackage : javaPackage.getSubPackages()) { - result.add(subPackage.getFqName()); - } - for (JavaClass javaClass : DescriptorResolverUtils.getClassesInPackage(javaPackage)) { - if (DescriptorResolverUtils.isJavaClassVisibleAsPackage(javaClass)) { - result.add(javaClass.getFqName()); - } - } - return result; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersCache.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersCache.java deleted file mode 100644 index 5d9963f178d..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersCache.java +++ /dev/null @@ -1,258 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.Visibilities; -import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; -import org.jetbrains.jet.lang.resolve.java.structure.*; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; - -/* package */ final class MembersCache { - private final Map> memberProcessingTasks = new HashMap>(); - private final Map namedMembersMap = new HashMap(); - - @Nullable - public NamedMembers get(@NotNull Name name) { - runTasksByName(name); - return namedMembersMap.get(name); - } - - @NotNull - public Collection allMembers() { - runAllTasks(); - memberProcessingTasks.clear(); - return namedMembersMap.values(); - } - - @NotNull - private NamedMembers getOrCreateEmpty(@NotNull JavaNamedElement element) { - Name name = element.getName(); - NamedMembers r = namedMembersMap.get(name); - if (r == null) { - r = new NamedMembers(name); - namedMembersMap.put(name, r); - } - return r; - } - - private void addTask(@NotNull JavaNamedElement member, @NotNull RunOnce task) { - Name name = member.getName(); - Collection tasks = memberProcessingTasks.get(name); - if (tasks == null) { - tasks = new HashSet(); - memberProcessingTasks.put(name, tasks); - } - tasks.add(task); - } - - private void runTasksByName(Name name) { - if (!memberProcessingTasks.containsKey(name)) return; - Collection tasks = memberProcessingTasks.get(name); - for (Runnable task : tasks) { - task.run(); - } - // Delete tasks - tasks.clear(); - } - - private void runAllTasks() { - for (Collection tasks : memberProcessingTasks.values()) { - for (Runnable task : tasks) { - task.run(); - } - } - } - - @NotNull - public static MembersCache buildForClass(@NotNull JavaClass javaClass, boolean staticMembers) { - MembersCache membersCache = new MembersCache(); - - membersCache.new ClassMemberProcessor(javaClass, staticMembers).process(); - membersCache.new ExtraPackageMembersProcessor(javaClass.getInnerClasses()).process(); - - return membersCache; - } - - @NotNull - public static MembersCache buildForPackage(@NotNull JavaPackage javaPackage) { - MembersCache membersCache = new MembersCache(); - - Collection classes = DescriptorResolverUtils.getClassesInPackage(javaPackage); - membersCache.new ExtraPackageMembersProcessor(classes).process(); - - return membersCache; - } - - private class ExtraPackageMembersProcessor { // 'extra' means that PSI elements for these members are not just top-level classes - @NotNull - private final Collection javaClasses; - - private ExtraPackageMembersProcessor(@NotNull Collection javaClasses) { - this.javaClasses = javaClasses; - } - - private void process() { - for (JavaClass javaClass : javaClasses) { - if (javaClass.getOriginKind() != JavaClass.OriginKind.KOTLIN_LIGHT_CLASS) { - if (SingleAbstractMethodUtils.isSamInterface(javaClass)) { - processSamInterface(javaClass); - } - } - } - } - - private void processSamInterface(@NotNull JavaClass javaClass) { - getOrCreateEmpty(javaClass).setSamInterface(javaClass); - } - } - - private class ClassMemberProcessor { - @NotNull - private final JavaClass javaClass; - private final boolean staticMembers; - - private ClassMemberProcessor(@NotNull JavaClass javaClass, boolean staticMembers) { - this.javaClass = javaClass; - this.staticMembers = staticMembers; - } - - private void process() { - processFields(); - processMethods(); - processNestedClasses(); - } - - private void processFields() { - for (final JavaField field : javaClass.getAllFields()) { - addTask(field, new RunOnce() { - @Override - public void doRun() { - processField(field); - } - }); - } - } - - private void processMethods() { - createEntriesForAllMethods(); - processOwnMethods(); - } - - private void createEntriesForAllMethods() { - for (JavaMethod method : javaClass.getAllMethods()) { - getOrCreateEmpty(method); - } - } - - private void processOwnMethods() { - for (final JavaMethod method : javaClass.getMethods()) { - addTask(method, new RunOnce() { - @Override - public void doRun() { - processOwnMethod(method); - } - }); - } - } - - private void processNestedClasses() { - if (!staticMembers) { - return; - } - for (final JavaClass nested : javaClass.getInnerClasses()) { - addTask(nested, new RunOnce() { - @Override - public void doRun() { - processNestedClass(nested); - } - }); - } - } - - private boolean includeMember(@NotNull JavaMember member) { - if (javaClass.isEnum() && staticMembers) { - return member.isStatic(); - } - - if (member.isStatic() != staticMembers) { - return false; - } - - if (!isInCurrentClass(member)) { - return false; - } - - if (member.getVisibility() == Visibilities.PRIVATE) { - return false; - } - - if (DescriptorResolverUtils.isObjectMethodInInterface(member)) { - return false; - } - - return true; - } - - private boolean isInCurrentClass(@NotNull JavaMember member) { - FqName fqName = member.getContainingClass().getFqName(); - return fqName != null && fqName.equals(javaClass.getFqName()); - } - - private void processField(@NotNull JavaField field) { - // group must be created even for excluded field - NamedMembers namedMembers = getOrCreateEmpty(field); - - if (includeMember(field)) { - namedMembers.addField(field); - } - } - - private void processOwnMethod(@NotNull JavaMethod ownMethod) { - if (includeMember(ownMethod)) { - getOrCreateEmpty(ownMethod).addMethod(ownMethod); - } - } - - private void processNestedClass(@NotNull JavaClass nested) { - if (SingleAbstractMethodUtils.isSamInterface(nested)) { - getOrCreateEmpty(nested).setSamInterface(nested); - } - } - } - - private static abstract class RunOnce implements Runnable { - private boolean hasRun = false; - - @Override - public final void run() { - if (hasRun) return; - hasRun = true; - doRun(); - } - - protected abstract void doRun(); - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java deleted file mode 100644 index 69e140f06c7..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.Collection; - -/* package */ class MembersProvider { - @Nullable - private final JavaClass javaClass; - @Nullable - private final JavaPackage javaPackage; - private final boolean staticMembers; - - private MembersCache membersCache; - - private MembersProvider(@Nullable JavaClass javaClass, @Nullable JavaPackage javaPackage, boolean staticMembers) { - this.javaClass = javaClass; - this.javaPackage = javaPackage; - this.staticMembers = staticMembers; - } - - @NotNull - public static MembersProvider forPackage(@NotNull JavaPackage javaPackage) { - return new MembersProvider(null, javaPackage, true); - } - - @NotNull - public static MembersProvider forClass(@NotNull JavaClass javaClass, boolean staticMembers) { - return new MembersProvider(javaClass, null, staticMembers); - } - - @Nullable - public NamedMembers get(@NotNull Name name) { - return getMembersCache().get(name); - } - - @NotNull - public Collection allMembers() { - return getMembersCache().allMembers(); - } - - @NotNull - private MembersCache getMembersCache() { - if (membersCache == null) { - if (javaClass != null) { - membersCache = MembersCache.buildForClass(javaClass, staticMembers); - } - else if (javaPackage != null) { - membersCache = MembersCache.buildForPackage(javaPackage); - } - else { - throw new IllegalStateException("MembersProvider should be created either for a class or for a package"); - } - } - return membersCache; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/NamedMembers.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/NamedMembers.java deleted file mode 100644 index e6014f25e4a..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/NamedMembers.java +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright 2010-2013 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.java.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaField; -import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.ArrayList; -import java.util.List; - -public final class NamedMembers { - - public NamedMembers(@NotNull Name name) { - this.name = name; - } - - @NotNull - private final Name name; - - @NotNull - private final List methods = new ArrayList(); - - @NotNull - private final List fields = new ArrayList(); - - @Nullable - private JavaClass samInterface; - - void addMethod(@NotNull JavaMethod method) { - methods.add(method); - } - - void addField(@NotNull JavaField field) { - fields.add(field); - } - - void setSamInterface(@NotNull JavaClass samInterface) { - this.samInterface = samInterface; - } - - @NotNull - public Name getName() { - return name; - } - - @NotNull - public List getMethods() { - return methods; - } - - @NotNull - public List getFields() { - return fields; - } - - @Nullable - public JavaClass getSamInterface() { - return samInterface; - } - - @Override - public String toString() { - return name + ": " + methods.size() + " methods, " + fields.size() + " fields"; - } -}