diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index 276559c40fc..7282344f297 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -22,8 +22,12 @@ import com.intellij.psi.impl.compiled.ClsClassImpl; import com.intellij.psi.util.PsiFormatUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMember; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -72,22 +76,6 @@ public final class DescriptorResolverUtils { return Collections.emptyList(); } - public static Visibility resolveVisibility(@NotNull PsiModifierListOwner modifierListOwner) { - if (modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC)) { - return Visibilities.PUBLIC; - } - if (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE)) { - return Visibilities.PRIVATE; - } - if (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED)) { - if (modifierListOwner.hasModifierProperty(PsiModifier.STATIC)) { - return JavaVisibilities.PROTECTED_STATIC_VISIBILITY; - } - return JavaVisibilities.PROTECTED_AND_PACKAGE; - } - return JavaVisibilities.PACKAGE_VISIBILITY; - } - @Nullable public static ValueParameterDescriptor getValueParameterDescriptorForAnnotationParameter( Name argumentName, @@ -124,11 +112,8 @@ public final class DescriptorResolverUtils { "valueOf(java.lang.String)".equals(signature); } - public static boolean isCorrectOwnerForEnumMember( - @NotNull ClassOrNamespaceDescriptor ownerDescriptor, - @NotNull PsiMember member - ) { - return isEnumClassObject(ownerDescriptor) == shouldBeInEnumClassObject(member); + public static boolean isCorrectOwnerForEnumMember(@NotNull ClassOrNamespaceDescriptor ownerDescriptor, @NotNull JavaMember member) { + return isEnumClassObject(ownerDescriptor) == shouldBeInEnumClassObject(member.getPsi()); } public static boolean isObjectMethodInInterface(@NotNull PsiMember member) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java index 747e412b9e0..c7f26a9824b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java @@ -23,25 +23,24 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.psi.JetPsiFactory; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiFieldWrapper; +import org.jetbrains.jet.lang.resolve.java.structure.JavaField; import org.jetbrains.jet.lang.types.JetType; import java.util.HashMap; public class AlternativeFieldSignatureData extends ElementAlternativeSignatureData { - private JetType altReturnType; - public AlternativeFieldSignatureData(@NotNull PsiFieldWrapper field, @NotNull JetType originalReturnType, boolean isVar) { - String signature = field.getSignatureAnnotation().signature(); + public AlternativeFieldSignatureData(@NotNull JavaField field, @NotNull JetType originalReturnType, boolean isVar) { + String signature = SignaturesUtil.getKotlinSignature(field); - if (signature.isEmpty()) { + if (signature == null) { setAnnotated(false); return; } setAnnotated(true); - Project project = field.getPsiMember().getProject(); + Project project = field.getPsi().getProject(); JetProperty altPropertyDeclaration = JetPsiFactory.createProperty(project, signature); try { @@ -61,10 +60,10 @@ public class AlternativeFieldSignatureData extends ElementAlternativeSignatureDa return altReturnType; } - private static void checkFieldAnnotation(JetProperty altProperty, PsiFieldWrapper fieldWrapper, boolean isVar) { - if (!ComparatorUtil.equalsNullable(fieldWrapper.getName(), altProperty.getName())) { + private static void checkFieldAnnotation(@NotNull JetProperty altProperty, @NotNull JavaField field, boolean isVar) { + if (!ComparatorUtil.equalsNullable(field.getName().asString(), altProperty.getName())) { throw new AlternativeSignatureMismatchException("Field name mismatch, original: %s, alternative: %s", - fieldWrapper.getName(), altProperty.getName()); + field.getName().asString(), altProperty.getName()); } if (altProperty.getTypeRef() == null) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java index 15fd8b69fed..72689c4bc99 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java @@ -22,12 +22,12 @@ import com.intellij.util.containers.ComparatorUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeSubstitutor; @@ -53,21 +53,22 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD private Map originalToAltTypeParameters; public AlternativeMethodSignatureData( - @NotNull PsiMethodWrapper method, + @NotNull JavaMethod method, @NotNull JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors, @Nullable JetType originalReturnType, @NotNull List methodTypeParameters, boolean hasSuperMethods ) { - String signature = method.getSignatureAnnotation().signature(); - if (signature.isEmpty()) { + String signature = SignaturesUtil.getKotlinSignature(method); + + if (signature == null) { setAnnotated(false); altFunDeclaration = null; return; } setAnnotated(true); - Project project = method.getPsiMethod().getProject(); + Project project = method.getPsi().getProject(); altFunDeclaration = JetPsiFactory.createFunction(project, signature); originalToAltTypeParameters = SignaturesUtil.recreateTypeParametersAndReturnMapping(methodTypeParameters, null); @@ -287,10 +288,10 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD return null; } - private static void checkEqualFunctionNames(PsiNamedElement namedElement, PsiMethodWrapper method) { - if (!ComparatorUtil.equalsNullable(method.getName(), namedElement.getName())) { + private static void checkEqualFunctionNames(@NotNull PsiNamedElement namedElement, @NotNull JavaMethod method) { + if (!ComparatorUtil.equalsNullable(method.getName().asString(), namedElement.getName())) { throw new AlternativeSignatureMismatchException("Function names mismatch, original: %s, alternative: %s", - method.getName(), namedElement.getName()); + method.getName().asString(), namedElement.getName()); } } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/KotlinSignatureAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/KotlinSignatureAnnotation.java deleted file mode 100644 index b7d54772069..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/KotlinSignatureAnnotation.java +++ /dev/null @@ -1,72 +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.kotlinSignature; - -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiAnnotationMemberValue; -import com.intellij.psi.PsiLiteralExpression; -import com.intellij.psi.PsiMember; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; - -public class KotlinSignatureAnnotation { - private static final KotlinSignatureAnnotation NULL_ANNOTATION = new KotlinSignatureAnnotation(null); - - static { - NULL_ANNOTATION.computeSignature(); - } - - @Nullable - private final PsiAnnotation psiAnnotation; - private String signature; - - private KotlinSignatureAnnotation(@Nullable PsiAnnotation psiAnnotation) { - this.psiAnnotation = psiAnnotation; - } - - @NotNull - public static KotlinSignatureAnnotation get(@NotNull PsiMember member) { - PsiAnnotation annotation = JavaAnnotationResolver.findAnnotationWithExternal(member, JvmAnnotationNames.KOTLIN_SIGNATURE); - return annotation != null ? new KotlinSignatureAnnotation(annotation) : NULL_ANNOTATION; - } - - @NotNull - private String computeSignature() { - if (psiAnnotation != null) { - PsiAnnotationMemberValue attribute = psiAnnotation.findAttributeValue(JvmAnnotationNames.KOTLIN_SIGNATURE_VALUE_FIELD_NAME); - if (attribute instanceof PsiLiteralExpression) { - Object value = ((PsiLiteralExpression) attribute).getValue(); - if (value instanceof String) { - return StringUtil.unescapeStringCharacters((String) value); - } - } - } - - return ""; - } - - @NotNull - public String signature() { - if (signature == null) { - signature = computeSignature(); - } - return signature; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java index 465deeb844d..1be40fbfa6f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java @@ -35,9 +35,12 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JetClsMethod; +import org.jetbrains.jet.lang.resolve.java.TypeUsage; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -68,7 +71,7 @@ public class SignaturesPropagationData { @NotNull JetType autoReturnType, // type built by JavaTypeTransformer from Java signature and @NotNull annotations @NotNull JavaDescriptorResolver.ValueParameterDescriptors autoValueParameters, // descriptors built by parameters resolver @NotNull List autoTypeParameters, // descriptors built by signature resolver - @NotNull PsiMethodWrapper method, + @NotNull JavaMethod method, @NotNull BindingTrace trace ) { this.containingClass = containingClass; @@ -206,7 +209,7 @@ public class SignaturesPropagationData { } private static List getSuperFunctionsForMethod( - @NotNull PsiMethodWrapper method, + @NotNull JavaMethod method, @NotNull BindingTrace trace, @NotNull ClassDescriptor containingClass ) { @@ -217,7 +220,7 @@ public class SignaturesPropagationData { Multimap> superclassToFunctions = getSuperclassToFunctionsMultimap(method, trace.getBindingContext(), containingClass); - for (PsiMethod superMethod : PropagationHeuristics.getSuperMethods(method.getPsiMethod())) { + for (PsiMethod superMethod : PropagationHeuristics.getSuperMethods(method.getPsi())) { PsiClass psiClass = superMethod.getContainingClass(); assert psiClass != null; String classFqNameString = psiClass.getQualifiedName(); @@ -237,7 +240,7 @@ public class SignaturesPropagationData { if (superFun == null) { // Super methods which are Object methods in interfaces are not loaded by JDR. if (!DescriptorResolverUtils.isObjectMethodInInterface(superMethod)) { - reportCantFindSuperFunction(method); + reportCantFindSuperFunction(method.getPsi()); } continue; } @@ -262,14 +265,14 @@ public class SignaturesPropagationData { @NotNull private static Multimap> getSuperclassToFunctionsMultimap( - @NotNull PsiMethodWrapper method, + @NotNull JavaMethod method, @NotNull BindingContext bindingContext, @NotNull ClassDescriptor containingClass ) { Multimap> result = HashMultimap.create(); - Name functionName = Name.identifier(method.getName()); - int parameterCount = method.getParameters().size(); + Name functionName = method.getName(); + int parameterCount = method.getValueParameters().size(); for (JetType supertype : TypeUtils.getAllSupertypes(containingClass.getDefaultType())) { ClassifierDescriptor klass = supertype.getConstructor().getDeclarationDescriptor(); @@ -690,9 +693,8 @@ public class SignaturesPropagationData { return builtIns.isArray(type) || builtIns.isPrimitiveArray(type); } - private static void reportCantFindSuperFunction(PsiMethodWrapper method) { - String errorMessage = "Can't find super function for " + method.getPsiMethod() + - " defined in " + method.getPsiMethod().getContainingClass(); + private static void reportCantFindSuperFunction(@NotNull PsiMethod psiMethod) { + String errorMessage = "Can't find super function for " + psiMethod + " defined in " + psiMethod.getContainingClass(); if (SystemInfo.isMac) { LOG.error("Remove duplicates from your JDK definition\n" + errorMessage); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java index 158ebf66582..904ee20c502 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java @@ -17,11 +17,18 @@ package org.jetbrains.jet.lang.resolve.java.kotlinSignature; import com.google.common.collect.Maps; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiAnnotationMemberValue; +import com.intellij.psi.PsiLiteralExpression; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; +import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMember; import org.jetbrains.jet.lang.types.TypeConstructor; import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lang.types.TypeSubstitutor; @@ -30,6 +37,9 @@ import java.util.List; import java.util.Map; public class SignaturesUtil { + private SignaturesUtil() { + } + public static Map recreateTypeParametersAndReturnMapping( @NotNull List originalParameters, @Nullable DeclarationDescriptor newOwner @@ -60,6 +70,20 @@ public class SignaturesUtil { return TypeSubstitutor.create(typeSubstitutionContext); } - private SignaturesUtil() { + @Nullable + public static String getKotlinSignature(@NotNull JavaMember member) { + PsiAnnotation annotation = JavaAnnotationResolver.findAnnotationWithExternal(member.getPsi(), JvmAnnotationNames.KOTLIN_SIGNATURE); + + if (annotation != null) { + PsiAnnotationMemberValue attribute = annotation.findAttributeValue(JvmAnnotationNames.KOTLIN_SIGNATURE_VALUE_FIELD_NAME); + if (attribute instanceof PsiLiteralExpression) { + Object value = ((PsiLiteralExpression) attribute).getValue(); + if (value instanceof String) { + return StringUtil.unescapeStringCharacters((String) value); + } + } + } + + return null; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java index 818da8bd95d..ad6442b17b2 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java @@ -18,20 +18,14 @@ package org.jetbrains.jet.lang.resolve.java.provider; import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiField; -import com.intellij.psi.PsiMember; -import com.intellij.psi.PsiMethod; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.Visibilities; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiFieldWrapper; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; +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; @@ -65,8 +59,8 @@ public final class MembersCache { return r; } - private void addTask(@NotNull PsiMember member, @NotNull RunOnce task) { - addTask(member.getName(), task); + private void addTask(@NotNull JavaNamedElement member, @NotNull RunOnce task) { + addTask(member.getName().asString(), task); } private void addTask(@Nullable String name, @NotNull RunOnce task) { @@ -123,29 +117,27 @@ public final class MembersCache { private void process() { for (JavaClass javaClass : javaClasses) { - PsiClass psiClass = javaClass.getPsi(); - - if (!(psiClass instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses - if (SingleAbstractMethodUtils.isSamInterface(psiClass)) { - processSamInterface(psiClass); + if (!(javaClass.getPsi() instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses + if (SingleAbstractMethodUtils.isSamInterface(javaClass)) { + processSamInterface(javaClass); } } } } - private void processSamInterface(@NotNull PsiClass psiClass) { - NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName())); - namedMembers.setSamInterface(psiClass); + private void processSamInterface(@NotNull JavaClass javaClass) { + NamedMembers namedMembers = getOrCreateEmpty(javaClass.getName()); + namedMembers.setSamInterface(javaClass); } } private class ClassMemberProcessor { @NotNull - private final PsiClass psiClass; + private final JavaClass javaClass; private final boolean staticMembers; private ClassMemberProcessor(@NotNull JavaClass javaClass, boolean staticMembers) { - this.psiClass = javaClass.getPsi(); + this.javaClass = javaClass; this.staticMembers = staticMembers; } @@ -156,7 +148,7 @@ public final class MembersCache { } private void processFields() { - for (final PsiField field : psiClass.getAllFields()) { + for (final JavaField field : javaClass.getAllFields()) { addTask(field, new RunOnce() { @Override public void doRun() { @@ -172,13 +164,13 @@ public final class MembersCache { } private void createEntriesForAllMethods() { - for (PsiMethod method : psiClass.getAllMethods()) { - getOrCreateEmpty(Name.identifier(method.getName())); + for (JavaMethod method : javaClass.getAllMethods()) { + getOrCreateEmpty(method.getName()); } } private void processOwnMethods() { - for (final PsiMethod method : psiClass.getMethods()) { + for (final JavaMethod method : javaClass.getMethods()) { addTask(method, new RunOnce() { @Override public void doRun() { @@ -192,7 +184,7 @@ public final class MembersCache { if (!staticMembers) { return; } - for (final PsiClass nested : psiClass.getInnerClasses()) { + for (final JavaClass nested : javaClass.getInnerClasses()) { addTask(nested, new RunOnce() { @Override public void doRun() { @@ -202,8 +194,8 @@ public final class MembersCache { } } - private boolean includeMember(PsiMemberWrapper member) { - if (psiClass.isEnum() && staticMembers) { + private boolean includeMember(@NotNull JavaMember member) { + if (javaClass.isEnum() && staticMembers) { return member.isStatic(); } @@ -211,48 +203,47 @@ public final class MembersCache { return false; } - if (member.getPsiMember().getContainingClass() != psiClass) { + if (!isInCurrentClass(member)) { return false; } - if (member.isPrivate()) { + if (member.getVisibility() == Visibilities.PRIVATE) { return false; } - if (DescriptorResolverUtils.isObjectMethodInInterface(member.getPsiMember())) { + if (DescriptorResolverUtils.isObjectMethodInInterface(member.getPsi())) { return false; } return true; } - private void processField(PsiField field) { - PsiFieldWrapper fieldWrapper = new PsiFieldWrapper(field); + private boolean isInCurrentClass(@NotNull JavaMember member) { + JavaClass containingClass = member.getContainingClass(); + if (containingClass == null) return false; + FqName fqName = containingClass.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(Name.identifier(fieldWrapper.getName())); + NamedMembers namedMembers = getOrCreateEmpty(field.getName()); - if (!includeMember(fieldWrapper)) { - return; + if (includeMember(field)) { + namedMembers.addField(field); } - - namedMembers.addField(fieldWrapper); } - private void processOwnMethod(PsiMethod ownMethod) { - PsiMethodWrapper method = new PsiMethodWrapper(ownMethod); - - if (!includeMember(method)) { - return; + private void processOwnMethod(@NotNull JavaMethod ownMethod) { + if (includeMember(ownMethod)) { + NamedMembers namedMembers = getOrCreateEmpty(ownMethod.getName()); + namedMembers.addMethod(ownMethod); } - - NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName())); - namedMembers.addMethod(method); } - private void processNestedClass(PsiClass nested) { + private void processNestedClass(@NotNull JavaClass nested) { if (SingleAbstractMethodUtils.isSamInterface(nested)) { - NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(nested.getName())); + NamedMembers namedMembers = getOrCreateEmpty(nested.getName()); namedMembers.setSamInterface(nested); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/NamedMembers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/NamedMembers.java index 38f04414ef7..e8978c7bf7b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/NamedMembers.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/NamedMembers.java @@ -17,11 +17,11 @@ package org.jetbrains.jet.lang.resolve.java.provider; import com.google.common.collect.Lists; -import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiFieldWrapper; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; +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.List; @@ -36,23 +36,23 @@ public final class NamedMembers { private final Name name; @NotNull - private final List methods = Lists.newArrayList(); + private final List methods = Lists.newArrayList(); @NotNull - private final List fields = Lists.newArrayList(); + private final List fields = Lists.newArrayList(); @Nullable - private PsiClass samInterface; + private JavaClass samInterface; - void addMethod(@NotNull PsiMethodWrapper method) { + void addMethod(@NotNull JavaMethod method) { methods.add(method); } - void addField(@NotNull PsiFieldWrapper field) { + void addField(@NotNull JavaField field) { fields.add(field); } - void setSamInterface(@NotNull PsiClass samInterface) { + void setSamInterface(@NotNull JavaClass samInterface) { this.samInterface = samInterface; } @@ -62,17 +62,17 @@ public final class NamedMembers { } @NotNull - public List getMethods() { + public List getMethods() { return methods; } @NotNull - public List getFields() { + public List getFields() { return fields; } @Nullable - public PsiClass getSamInterface() { + public JavaClass getSamInterface() { return samInterface; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index 715a717f322..9bce1ca9a0e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -71,22 +71,21 @@ public final class JavaConstructorResolver { public Collection resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor containingClass) { PsiClass psiClass = javaClass.getPsi(); - Collection constructors = Lists.newArrayList(); + Collection result = Lists.newArrayList(); List typeParameters = containingClass.getTypeConstructor().getParameters(); TypeVariableResolver typeVariableResolver = - new TypeVariableResolver(typeParameters, containingClass, "class " + psiClass.getQualifiedName()); + new TypeVariableResolver(typeParameters, containingClass, "class " + javaClass.getFqName()); - PsiMethod[] psiConstructors = psiClass.getConstructors(); + Collection constructors = javaClass.getConstructors(); - boolean isStatic = psiClass.hasModifierProperty(PsiModifier.STATIC); if (containingClass.getKind() == ClassKind.OBJECT || containingClass.getKind() == ClassKind.CLASS_OBJECT) { - constructors.add(DescriptorResolver.createPrimaryConstructorForObject(containingClass)); + result.add(DescriptorResolver.createPrimaryConstructorForObject(containingClass)); } - else if (psiConstructors.length == 0) { + else if (constructors.isEmpty()) { if (trace.get(BindingContext.CONSTRUCTOR, psiClass) != null) { - constructors.add(trace.get(BindingContext.CONSTRUCTOR, psiClass)); + result.add(trace.get(BindingContext.CONSTRUCTOR, psiClass)); } else { Visibility constructorVisibility = getConstructorVisibility(containingClass); @@ -94,17 +93,18 @@ public final class JavaConstructorResolver { // Example: // class Kotlin() : Java() {} // abstract public class Java {} - if (!psiClass.isInterface()) { + if (!javaClass.isInterface()) { ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( containingClass, Collections.emptyList(), true); constructorDescriptor - .initialize(typeParameters, Collections.emptyList(), constructorVisibility, isStatic); - constructors.add(constructorDescriptor); + .initialize(typeParameters, Collections.emptyList(), constructorVisibility, + javaClass.isStatic()); + result.add(constructorDescriptor); trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor); } - if (psiClass.isAnnotationType()) { + if (javaClass.isAnnotationType()) { // A constructor for an annotation type takes all the "methods" in the @interface as parameters ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( containingClass, @@ -141,27 +141,25 @@ public final class JavaConstructorResolver { } } - constructorDescriptor.initialize(typeParameters, valueParameters, constructorVisibility, isStatic); - constructors.add(constructorDescriptor); + constructorDescriptor.initialize(typeParameters, valueParameters, constructorVisibility, javaClass.isStatic()); + result.add(constructorDescriptor); trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor); } } } else { - for (PsiMethod psiConstructor : psiConstructors) { - ConstructorDescriptor constructor = resolveConstructor(psiClass, isStatic, psiConstructor, containingClass); - if (constructor != null) { - constructors.add(constructor); - ContainerUtil.addIfNotNull(constructors, resolveSamAdapter(constructor)); - } + for (JavaMethod constructor : constructors) { + ConstructorDescriptor descriptor = resolveConstructor(javaClass, constructor, containingClass); + result.add(descriptor); + ContainerUtil.addIfNotNull(result, resolveSamAdapter(descriptor)); } } - for (ConstructorDescriptor constructor : constructors) { + for (ConstructorDescriptor constructor : result) { ((ConstructorDescriptorImpl) constructor).setReturnType(containingClass.getDefaultType()); } - return constructors; + return result; } @NotNull @@ -173,17 +171,15 @@ public final class JavaConstructorResolver { return visibility; } - @Nullable + @NotNull private ConstructorDescriptor resolveConstructor( - PsiClass psiClass, - boolean aStatic, - PsiMethod psiConstructor, - ClassDescriptor classDescriptor + @NotNull JavaClass javaClass, + @NotNull JavaMethod constructor, + @NotNull ClassDescriptor classDescriptor ) { - PsiMethodWrapper constructor = new PsiMethodWrapper(psiConstructor); - - if (trace.get(BindingContext.CONSTRUCTOR, psiConstructor) != null) { - return trace.get(BindingContext.CONSTRUCTOR, psiConstructor); + ConstructorDescriptor alreadyResolved = trace.get(BindingContext.CONSTRUCTOR, constructor.getPsi()); + if (alreadyResolved != null) { + return alreadyResolved; } ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( @@ -194,8 +190,8 @@ public final class JavaConstructorResolver { List typeParameters = classDescriptor.getTypeConstructor().getParameters(); JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors( - constructorDescriptor, constructor.getParameters(), - new TypeVariableResolver(typeParameters, classDescriptor, "constructor of class " + psiClass.getQualifiedName()) + constructorDescriptor, constructor.getValueParameters(), + new TypeVariableResolver(typeParameters, classDescriptor, "constructor of class " + javaClass.getFqName()) ); if (valueParameterDescriptors.getReceiverType() != null) { @@ -215,9 +211,9 @@ public final class JavaConstructorResolver { constructorDescriptor.initialize(typeParameters, valueParameterDescriptors.getDescriptors(), - DescriptorResolverUtils.resolveVisibility(psiConstructor), - aStatic); - trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor); + constructor.getVisibility(), + javaClass.isStatic()); + trace.record(BindingContext.CONSTRUCTOR, constructor.getPsi(), constructorDescriptor); return constructorDescriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index c6329373933..3f39f1ae894 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiType; import com.intellij.psi.util.PsiFormatUtil; @@ -34,9 +33,9 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData; +import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; @@ -96,41 +95,40 @@ public final class JavaFunctionResolver { @Nullable private SimpleFunctionDescriptor resolveMethodToFunctionDescriptor( - @NotNull JavaMethod javaMethod, + @NotNull JavaMethod method, @NotNull ClassOrNamespaceDescriptor ownerDescriptor, boolean record ) { - PsiMethodWrapper method = new PsiMethodWrapper(javaMethod.getPsi()); - - if (!DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, method.getPsiMember())) { + if (!DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, method)) { return null; } - PsiType returnPsiType = method.getReturnType(); + PsiMethod psiMethod = method.getPsi(); + + PsiType returnPsiType = psiMethod.getReturnType(); if (returnPsiType == null) { return null; } - PsiMethod psiMethod = method.getPsiMethod(); - - if (trace.get(BindingContext.FUNCTION, psiMethod) != null) { - return trace.get(BindingContext.FUNCTION, psiMethod); + SimpleFunctionDescriptor alreadyResolved = trace.get(BindingContext.FUNCTION, psiMethod); + if (alreadyResolved != null) { + return alreadyResolved; } SimpleFunctionDescriptorImpl functionDescriptorImpl = new SimpleFunctionDescriptorImpl( ownerDescriptor, annotationResolver.resolveAnnotations(psiMethod), - Name.identifier(method.getName()), + method.getName(), CallableMemberDescriptor.Kind.DECLARATION ); List methodTypeParameters = signatureResolver.resolveMethodTypeParameters(method, functionDescriptorImpl); TypeVariableResolver methodTypeVariableResolver = new TypeVariableResolver( - methodTypeParameters, functionDescriptorImpl, "method " + method.getName() + " in class " + psiMethod.getContainingClass()); + methodTypeParameters, functionDescriptorImpl, "method " + method.getName() + " in class " + method.getContainingClass()); JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = parameterResolver - .resolveParameterDescriptors(functionDescriptorImpl, method.getParameters(), methodTypeVariableResolver); + .resolveParameterDescriptors(functionDescriptorImpl, method.getValueParameters(), methodTypeVariableResolver); JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver); List signatureErrors = Lists.newArrayList(); @@ -170,7 +168,7 @@ public final class JavaFunctionResolver { valueParameterDescriptors.getDescriptors(), returnType, Modality.convertFromFlags(method.isAbstract(), !method.isFinal()), - DescriptorResolverUtils.resolveVisibility(psiMethod), + method.getVisibility(), /*isInline = */ false ); @@ -199,9 +197,9 @@ public final class JavaFunctionResolver { } private static void checkFunctionsOverrideCorrectly( - PsiMethodWrapper method, - List superFunctions, - FunctionDescriptor functionDescriptor + @NotNull JavaMethod method, + @NotNull List superFunctions, + @NotNull FunctionDescriptor functionDescriptor ) { for (FunctionDescriptor superFunction : superFunctions) { ClassDescriptor klass = (ClassDescriptor) functionDescriptor.getContainingDeclaration(); @@ -230,8 +228,8 @@ public final class JavaFunctionResolver { + "super class = " + superFunction.getContainingDeclaration() + "\n" + "sub function = " + functionDescriptor + "\n" + "sub class = " + functionDescriptor.getContainingDeclaration() + "\n" - + "sub method = " + PsiFormatUtil.getExternalName(method.getPsiMethod()) + "\n" - + "@KotlinSignature = " + method.getSignatureAnnotation().signature()); + + "sub method = " + PsiFormatUtil.getExternalName(method.getPsi()) + "\n" + + "@KotlinSignature = " + SignaturesUtil.getKotlinSignature(method)); } } } @@ -246,8 +244,8 @@ public final class JavaFunctionResolver { } Set functionsFromCurrent = Sets.newHashSet(); - for (PsiMethodWrapper method : members.getMethods()) { - SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(new JavaMethod(method.getPsiMethod()), owner, true); + for (JavaMethod method : members.getMethods()) { + SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(method, owner, true); if (function != null) { functionsFromCurrent.add(function); ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function)); @@ -336,15 +334,11 @@ public final class JavaFunctionResolver { } @Nullable - private SimpleFunctionDescriptor resolveSamConstructor( - @NotNull NamespaceDescriptor ownerDescriptor, - @NotNull NamedMembers namedMembers - ) { - PsiClass samInterface = namedMembers.getSamInterface(); - if (samInterface != null) { - ClassDescriptorFromJvmBytecode klass = findClassInNamespace(ownerDescriptor, namedMembers.getName()); + private SimpleFunctionDescriptor resolveSamConstructor(@NotNull NamespaceDescriptor owner, @NotNull NamedMembers namedMembers) { + if (namedMembers.getSamInterface() != null) { + ClassDescriptorFromJvmBytecode klass = findClassInNamespace(owner, namedMembers.getName()); if (klass != null) { - return recordSamConstructor(klass, createSamConstructorFunction(ownerDescriptor, klass), trace); + return recordSamConstructor(klass, createSamConstructorFunction(owner, klass), trace); } } return null; @@ -368,15 +362,16 @@ public final class JavaFunctionResolver { @NotNull private JetType makeReturnType( - PsiType returnType, PsiMethodWrapper method, + @NotNull PsiType returnType, + @NotNull JavaMethod method, @NotNull TypeVariableResolver typeVariableResolver ) { + PsiMethod psiMethod = method.getPsi(); - TypeUsage typeUsage = JavaTypeTransformer - .adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT); + TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(psiMethod, TypeUsage.MEMBER_SIGNATURE_COVARIANT); JetType transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver); - if (JavaAnnotationResolver.findAnnotationWithExternal(method.getPsiMethod(), JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION) != null) { + if (JavaAnnotationResolver.findAnnotationWithExternal(psiMethod, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION) != null) { return TypeUtils.makeNullableAsSpecified(transformedType, false); } else { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java index 5f51a1bf81a..1eccaa4dc59 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java @@ -238,7 +238,7 @@ public final class JavaNamespaceResolver { } for (PsiClass nestedClass : psiClass.getInnerClasses()) { - if (SingleAbstractMethodUtils.isSamInterface(nestedClass)) { + if (SingleAbstractMethodUtils.isSamInterface(new JavaClass(nestedClass))) { return true; } if (nestedClass.hasModifierProperty(PsiModifier.STATIC) && hasStaticMembers(nestedClass)) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index bdd5c8a3737..36e0705ec00 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Sets; -import com.intellij.psi.PsiEnumConstant; import com.intellij.psi.PsiExpression; import com.intellij.psi.PsiLiteralExpression; import org.jetbrains.annotations.NotNull; @@ -31,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiFieldWrapper; +import org.jetbrains.jet.lang.resolve.java.structure.JavaField; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; @@ -70,13 +69,13 @@ public final class JavaPropertyResolver { public Set resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor ownerDescriptor) { Name propertyName = members.getName(); - List fields = members.getFields(); + List fields = members.getFields(); Set propertiesFromCurrent = new HashSet(1); assert fields.size() <= 1; if (fields.size() == 1) { - PsiFieldWrapper field = fields.iterator().next(); - if (DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, field.getPsiField())) { + JavaField field = fields.iterator().next(); + if (DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, field)) { propertiesFromCurrent.add(resolveProperty(ownerDescriptor, propertyName, "class or namespace " + DescriptorUtils.getFQName(ownerDescriptor), field)); } @@ -128,14 +127,11 @@ public final class JavaPropertyResolver { @NotNull ClassOrNamespaceDescriptor owner, @NotNull Name propertyName, @NotNull String context, - @NotNull PsiFieldWrapper field + @NotNull JavaField field ) { boolean isVar = !field.isFinal(); - Visibility visibility = DescriptorResolverUtils.resolveVisibility(field.getPsiField()); - - PropertyDescriptorImpl propertyDescriptor = - createPropertyDescriptor(owner, propertyName, field, isVar, visibility); + PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, field, isVar); propertyDescriptor.initialize(null, null); @@ -153,12 +149,12 @@ public final class JavaPropertyResolver { DescriptorUtils.getExpectedThisObjectIfNeeded(owner), (JetType) null ); - trace.record(BindingContext.VARIABLE, field.getPsiField(), propertyDescriptor); + trace.record(BindingContext.VARIABLE, field.getPsi(), propertyDescriptor); trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor); if (AnnotationUtils.isPropertyAcceptableAsAnnotationParameter(propertyDescriptor)) { - PsiExpression initializer = field.getPsiField().getInitializer(); + PsiExpression initializer = field.getPsi().getInitializer(); if (initializer instanceof PsiLiteralExpression) { CompileTimeConstant constant = JavaCompileTimeConstResolver .resolveCompileTimeConstantValue(((PsiLiteralExpression) initializer).getValue(), propertyType); @@ -174,12 +170,13 @@ public final class JavaPropertyResolver { private PropertyDescriptorImpl createPropertyDescriptor( @NotNull ClassOrNamespaceDescriptor owner, @NotNull Name propertyName, - @NotNull PsiFieldWrapper field, - boolean isVar, - @NotNull Visibility visibility + @NotNull JavaField field, + boolean isVar ) { - boolean isEnumEntry = field.getPsiField() instanceof PsiEnumConstant; - if (isEnumEntry) { + List annotations = annotationResolver.resolveAnnotations(field.getPsi()); + Visibility visibility = field.getVisibility(); + + if (field.isEnumEntry()) { assert !isVar : "Enum entries should be immutable."; assert DescriptorUtils.isEnumClassObject(owner) : "Enum entries should be put into class object of enum only: " + owner; //TODO: this is a hack to indicate that this enum entry is an object @@ -194,14 +191,14 @@ public final class JavaPropertyResolver { false); return new PropertyDescriptorForObjectImpl( owner, - annotationResolver.resolveAnnotations(field.getPsiField()), + annotations, visibility, propertyName, dummyClassDescriptorForEnumEntryObject); } return new PropertyDescriptorImpl( owner, - annotationResolver.resolveAnnotations(field.getPsiField()), + annotations, Modality.FINAL, visibility, isVar, @@ -212,9 +209,9 @@ public final class JavaPropertyResolver { @NotNull private JetType getAlternativeSignatureData( boolean isVar, - PsiFieldWrapper field, - PropertyDescriptor propertyDescriptor, - JetType propertyType + @NotNull JavaField field, + @NotNull PropertyDescriptor propertyDescriptor, + @NotNull JetType propertyType ) { AlternativeFieldSignatureData signatureData = new AlternativeFieldSignatureData(field, propertyType, isVar); if (signatureData.hasErrors()) { @@ -228,11 +225,11 @@ public final class JavaPropertyResolver { } @NotNull - private JetType getPropertyType(@NotNull PsiFieldWrapper field, @NotNull TypeVariableResolver typeVariableResolver) { - JetType propertyType = typeTransformer.transformToType(field.getType(), typeVariableResolver); + private JetType getPropertyType(@NotNull JavaField field, @NotNull TypeVariableResolver typeVariableResolver) { + JetType propertyType = typeTransformer.transformToType(field.getPsi().getType(), typeVariableResolver); boolean hasNotNullAnnotation = JavaAnnotationResolver.findAnnotationWithExternal( - field.getPsiField(), + field.getPsi(), JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION ) != null; @@ -255,7 +252,7 @@ public final class JavaPropertyResolver { return r; } - private static boolean isStaticFinalField(@NotNull PsiFieldWrapper wrapper) { - return wrapper.isFinal() && wrapper.isStatic(); + private static boolean isStaticFinalField(@NotNull JavaField field) { + return field.isFinal() && field.isStatic(); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java index e8cd7fa1045..a2c65308f08 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java @@ -17,10 +17,7 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Lists; -import com.intellij.psi.PsiClass; import com.intellij.psi.PsiClassType; -import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiTypeParameter; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; @@ -32,8 +29,8 @@ import org.jetbrains.jet.lang.resolve.java.TypeUsage; import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.structure.JavaClassType; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.Variance; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -71,16 +68,14 @@ public final class JavaSignatureResolver { } } - + @NotNull private static List makeUninitializedTypeParameters( - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull PsiTypeParameter[] typeParameters + @NotNull DeclarationDescriptor container, + @NotNull Collection typeParameters ) { List result = Lists.newArrayList(); - for (PsiTypeParameter typeParameter : typeParameters) { - TypeParameterDescriptorInitialization typeParameterDescriptor = - makeUninitializedTypeParameter(containingDeclaration, new JavaTypeParameter(typeParameter)); - result.add(typeParameterDescriptor); + for (JavaTypeParameter typeParameter : typeParameters) { + result.add(makeUninitializedTypeParameter(container, typeParameter)); } return result; } @@ -88,17 +83,17 @@ public final class JavaSignatureResolver { @NotNull private static TypeParameterDescriptorInitialization makeUninitializedTypeParameter( @NotNull DeclarationDescriptor containingDeclaration, - @NotNull JavaTypeParameter javaTypeParameter + @NotNull JavaTypeParameter typeParameter ) { TypeParameterDescriptorImpl typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification( containingDeclaration, Collections.emptyList(), // TODO false, Variance.INVARIANT, - javaTypeParameter.getName(), - javaTypeParameter.getIndex() + typeParameter.getName(), + typeParameter.getIndex() ); - return new TypeParameterDescriptorInitialization(typeParameterDescriptor, javaTypeParameter); + return new TypeParameterDescriptorInitialization(typeParameterDescriptor, typeParameter); } private void initializeTypeParameter( @@ -153,19 +148,18 @@ public final class JavaSignatureResolver { } + @NotNull public List resolveMethodTypeParameters( - @NotNull PsiMethodWrapper method, + @NotNull JavaMethod method, @NotNull DeclarationDescriptor functionDescriptor ) { - - PsiMethod psiMethod = method.getPsiMethod(); List typeParametersIntialization = - makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters()); + makeUninitializedTypeParameters(functionDescriptor, method.getTypeParameters()); - PsiClass psiMethodContainingClass = psiMethod.getContainingClass(); - assert psiMethodContainingClass != null; - String context = "method " + method.getName() + " in class " + psiMethodContainingClass.getQualifiedName(); - initializeTypeParameters(typeParametersIntialization, functionDescriptor, context); + JavaClass containingClass = method.getContainingClass(); + assert containingClass != null; + initializeTypeParameters(typeParametersIntialization, functionDescriptor, + "method " + method.getName() + " in class " + containingClass.getFqName()); List typeParameters = Lists.newArrayListWithCapacity(typeParametersIntialization.size()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java index ceb877de3be..fb63f22996c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.java.*; +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; @@ -33,11 +34,11 @@ 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; public final class JavaValueParameterResolver { - private JavaTypeTransformer typeTransformer; public JavaValueParameterResolver() { @@ -45,18 +46,21 @@ public final class JavaValueParameterResolver { @NotNull private ValueParameterDescriptor resolveParameterDescriptor( - DeclarationDescriptor containingDeclaration, int i, - PsiParameter parameter, TypeVariableResolver typeVariableResolver + @NotNull DeclarationDescriptor containingDeclaration, + int i, + @NotNull JavaValueParameter parameter, + @NotNull TypeVariableResolver typeVariableResolver ) { + PsiParameter psiParameter = parameter.getPsi(); - PsiType psiType = parameter.getType(); + PsiType psiType = psiParameter.getType(); // TODO: must be very slow, make it lazy? - Name name = Name.identifier(getParameterName(i, parameter)); + Name name = getParameterName(i, parameter); TypeUsage typeUsage = JavaTypeTransformer - .adjustTypeUsageWithMutabilityAnnotations(parameter, TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT); - JetType outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver); + .adjustTypeUsageWithMutabilityAnnotations(psiParameter, TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT); + JetType outType = typeTransformer.transformToType(psiType, typeUsage, typeVariableResolver); JetType varargElementType; if (psiType instanceof PsiEllipsisType) { @@ -69,7 +73,7 @@ public final class JavaValueParameterResolver { JetType transformedType; PsiAnnotation notNullAnnotation = JavaAnnotationResolver - .findAnnotationWithExternal(parameter, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION); + .findAnnotationWithExternal(psiParameter, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION); if (notNullAnnotation != null) { transformedType = TypeUtils.makeNullableAsSpecified(outType, false); } @@ -87,33 +91,29 @@ public final class JavaValueParameterResolver { ); } - @NotNull - private JavaTypeTransformer getTypeTransformer() { - return typeTransformer; - } - @Inject public void setTypeTransformer(JavaTypeTransformer typeTransformer) { this.typeTransformer = typeTransformer; } @NotNull - private static String getParameterName(int number, @NotNull PsiParameter parameter) { - String psiParameterName = parameter.getName(); - return psiParameterName != null ? psiParameterName : "p" + number; + private static Name getParameterName(int number, @NotNull JavaValueParameter parameter) { + Name psiParameterName = parameter.getName(); + return psiParameterName != null ? psiParameterName : Name.identifier("p" + number); } + @NotNull public JavaDescriptorResolver.ValueParameterDescriptors resolveParameterDescriptors( - DeclarationDescriptor containingDeclaration, - List parameters, TypeVariableResolver typeVariableResolver + @NotNull DeclarationDescriptor container, + @NotNull Collection parameters, + @NotNull TypeVariableResolver typeVariableResolver ) { - List result = new ArrayList(); - int indexDelta = 0; - for (int i = 0, parametersLength = parameters.size(); i < parametersLength; i++) { - PsiParameter parameter = parameters.get(i); - ValueParameterDescriptor parameterDescriptor = - resolveParameterDescriptor(containingDeclaration, i + indexDelta, parameter, typeVariableResolver); + List result = new ArrayList(parameters.size()); + int index = 0; + for (JavaValueParameter parameter : parameters) { + ValueParameterDescriptor parameterDescriptor = resolveParameterDescriptor(container, index, parameter, typeVariableResolver); result.add(parameterDescriptor); + index++; } return new JavaDescriptorResolver.ValueParameterDescriptors(null, result); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java index 906daf394dd..99e3eb1fa99 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java @@ -320,8 +320,8 @@ public class SingleAbstractMethodUtils { private SingleAbstractMethodUtils() { } - public static boolean isSamInterface(@NotNull PsiClass psiClass) { - return getSamInterfaceMethod(new JavaClass(psiClass), psiClass.getProject()) != null; + public static boolean isSamInterface(@NotNull JavaClass javaClass) { + return getSamInterfaceMethod(javaClass, javaClass.getPsi().getProject()) != null; } // Returns null if not SAM interface diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java index 33bff08342a..8ebbaf3e638 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java @@ -18,25 +18,20 @@ package org.jetbrains.jet.lang.resolve.java.structure; import com.intellij.psi.PsiAnnotation; import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiModifier; import com.intellij.psi.PsiModifierList; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.Modality; -import org.jetbrains.jet.lang.descriptors.Visibilities; -import org.jetbrains.jet.lang.descriptors.Visibility; -import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; -import java.util.Collections; import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.*; -public class JavaClass extends JavaElementImpl implements JavaNamedElement, JavaModifierListOwner, JavaTypeParameterListOwner { +public class JavaClass extends JavaModifierListOwnerImpl implements JavaNamedElement, JavaTypeParameterListOwner { public JavaClass(@NotNull PsiClass psiClass) { super(psiClass); } @@ -107,46 +102,6 @@ public class JavaClass extends JavaElementImpl implements JavaNamedElement, Java return isAnnotationType() ? Modality.FINAL : Modality.convertFromFlags(isAbstract() || isInterface(), !isFinal()); } - @Override - public boolean isAbstract() { - return getPsi().hasModifierProperty(PsiModifier.ABSTRACT); - } - - @Override - public boolean isFinal() { - return getPsi().hasModifierProperty(PsiModifier.FINAL); - } - - @Override - public boolean isStatic() { - return getPsi().hasModifierProperty(PsiModifier.STATIC); - } - - @NotNull - @Override - public Visibility getVisibility() { - if (getPsi().hasModifierProperty(PsiModifier.PUBLIC)) { - return Visibilities.PUBLIC; - } - if (getPsi().hasModifierProperty(PsiModifier.PRIVATE)) { - return Visibilities.PRIVATE; - } - if (getPsi().hasModifierProperty(PsiModifier.PROTECTED)) { - return isStatic() ? JavaVisibilities.PROTECTED_STATIC_VISIBILITY : JavaVisibilities.PROTECTED_AND_PACKAGE; - } - return JavaVisibilities.PACKAGE_VISIBILITY; - } - - @NotNull - @Override - public Collection getAnnotations() { - PsiModifierList modifierList = getPsi().getModifierList(); - if (modifierList != null) { - return annotations(modifierList.getAnnotations()); - } - return Collections.emptyList(); - } - @NotNull @Override public Collection getTypeParameters() { @@ -166,4 +121,19 @@ public class JavaClass extends JavaElementImpl implements JavaNamedElement, Java public Collection getMethods() { return methods(getPsi().getMethods()); } + + @NotNull + public Collection getAllMethods() { + return methods(getPsi().getAllMethods()); + } + + @NotNull + public Collection getAllFields() { + return fields(getPsi().getAllFields()); + } + + @NotNull + public Collection getConstructors() { + return methods(getPsi().getConstructors()); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java index a255a6a14ba..f0378fc0b0d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java @@ -58,6 +58,26 @@ import java.util.List; return result; } + @NotNull + public static Collection fields(@NotNull PsiField[] fields) { + if (fields.length == 0) return Collections.emptyList(); + List result = new ArrayList(fields.length); + for (PsiField psiField : fields) { + result.add(new JavaField(psiField)); + } + return result; + } + + @NotNull + public static Collection valueParameters(@NotNull PsiParameter[] parameters) { + if (parameters.length == 0) return Collections.emptyList(); + List result = new ArrayList(parameters.length); + for (PsiParameter psiParameter : parameters) { + result.add(new JavaValueParameter(psiParameter)); + } + return result; + } + @NotNull public static Collection typeParameters(@NotNull PsiTypeParameter[] typeParameters) { if (typeParameters.length == 0) return Collections.emptyList(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java new file mode 100644 index 00000000000..0766ad4b171 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java @@ -0,0 +1,46 @@ +/* + * 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.structure; + +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiEnumConstant; +import com.intellij.psi.PsiField; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +public class JavaField extends JavaMemberImpl { + public JavaField(@NotNull PsiField psiField) { + super(psiField); + } + + @NotNull + @Override + public PsiField getPsi() { + return (PsiField) super.getPsi(); + } + + @Nullable + @Override + public JavaClass getContainingClass() { + PsiClass psiClass = getPsi().getContainingClass(); + return psiClass == null ? null : new JavaClass(psiClass); + } + + public boolean isEnumEntry() { + return getPsi() instanceof PsiEnumConstant; + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMember.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMember.java index 4f7fbe50202..b88e9572a56 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMember.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMember.java @@ -16,9 +16,15 @@ package org.jetbrains.jet.lang.resolve.java.structure; +import com.intellij.psi.PsiMember; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public interface JavaMember extends JavaElement { +public interface JavaMember extends JavaModifierListOwner, JavaNamedElement { + @NotNull + @Override + PsiMember getPsi(); + // TODO: NotNull ? @Nullable JavaClass getContainingClass(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiFieldWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMemberImpl.java similarity index 57% rename from compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiFieldWrapper.java rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMemberImpl.java index 8c09dbb495a..21d8dfd7653 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiFieldWrapper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMemberImpl.java @@ -14,28 +14,28 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.resolve.java.wrapper; +package org.jetbrains.jet.lang.resolve.java.structure; -import com.intellij.psi.PsiField; import com.intellij.psi.PsiMember; -import com.intellij.psi.PsiType; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.name.Name; -public class PsiFieldWrapper extends PsiMemberWrapper { - public PsiFieldWrapper(@NotNull PsiMember psiMember) { +public abstract class JavaMemberImpl extends JavaModifierListOwnerImpl implements JavaMember { + protected JavaMemberImpl(@NotNull PsiMember psiMember) { super(psiMember); } - - public PsiField getPsiField() { - return (PsiField) psiMember; - } - - public PsiType getType() { - return getPsiField().getType(); + + @NotNull + @Override + public PsiMember getPsi() { + return (PsiMember) super.getPsi(); } + @NotNull @Override - public boolean isAbstract() { - return false; + public Name getName() { + String name = getPsi().getName(); + assert name != null : "Member must have a name: " + getPsi(); + return Name.identifier(name); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java index 67aae316b01..6d8fc45f3c7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java @@ -25,8 +25,9 @@ import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.typeParameters; +import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.valueParameters; -public class JavaMethod extends JavaElementImpl implements JavaTypeParameterListOwner, JavaNamedElement, JavaMember { +public class JavaMethod extends JavaMemberImpl implements JavaTypeParameterListOwner { public JavaMethod(@NotNull PsiMethod psiMethod) { super(psiMethod); } @@ -56,4 +57,9 @@ public class JavaMethod extends JavaElementImpl implements JavaTypeParameterList public Collection getTypeParameters() { return typeParameters(getPsi().getTypeParameters()); } + + @NotNull + public Collection getValueParameters() { + return valueParameters(getPsi().getParameterList().getParameters()); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaModifierListOwnerImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaModifierListOwnerImpl.java new file mode 100644 index 00000000000..aebabfd0234 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaModifierListOwnerImpl.java @@ -0,0 +1,82 @@ +/* + * 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.structure; + +import com.intellij.psi.PsiModifier; +import com.intellij.psi.PsiModifierList; +import com.intellij.psi.PsiModifierListOwner; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.Visibilities; +import org.jetbrains.jet.lang.descriptors.Visibility; +import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; + +import java.util.Collection; +import java.util.Collections; + +import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.annotations; + +public abstract class JavaModifierListOwnerImpl extends JavaElementImpl implements JavaModifierListOwner { + protected JavaModifierListOwnerImpl(@NotNull PsiModifierListOwner psiModifierListOwner) { + super(psiModifierListOwner); + } + + @NotNull + @Override + public PsiModifierListOwner getPsi() { + return (PsiModifierListOwner) super.getPsi(); + } + + @Override + public boolean isAbstract() { + return getPsi().hasModifierProperty(PsiModifier.ABSTRACT); + } + + @Override + public boolean isStatic() { + return getPsi().hasModifierProperty(PsiModifier.STATIC); + } + + @Override + public boolean isFinal() { + return getPsi().hasModifierProperty(PsiModifier.FINAL); + } + + @NotNull + @Override + public Visibility getVisibility() { + if (getPsi().hasModifierProperty(PsiModifier.PUBLIC)) { + return Visibilities.PUBLIC; + } + if (getPsi().hasModifierProperty(PsiModifier.PRIVATE)) { + return Visibilities.PRIVATE; + } + if (getPsi().hasModifierProperty(PsiModifier.PROTECTED)) { + return isStatic() ? JavaVisibilities.PROTECTED_STATIC_VISIBILITY : JavaVisibilities.PROTECTED_AND_PACKAGE; + } + return JavaVisibilities.PACKAGE_VISIBILITY; + } + + @NotNull + @Override + public Collection getAnnotations() { + PsiModifierList modifierList = getPsi().getModifierList(); + if (modifierList != null) { + return annotations(modifierList.getAnnotations()); + } + return Collections.emptyList(); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java new file mode 100644 index 00000000000..5e9c254a772 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java @@ -0,0 +1,40 @@ +/* + * 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.structure; + +import com.intellij.psi.PsiParameter; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.name.Name; + +public class JavaValueParameter extends JavaElementImpl { + public JavaValueParameter(@NotNull PsiParameter psiParameter) { + super(psiParameter); + } + + @NotNull + @Override + public PsiParameter getPsi() { + return (PsiParameter) super.getPsi(); + } + + @Nullable + public Name getName() { + String name = getPsi().getName(); + return name == null ? null : Name.identifier(name); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMemberWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMemberWrapper.java deleted file mode 100644 index 39cbd02fd59..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMemberWrapper.java +++ /dev/null @@ -1,69 +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.wrapper; - -import com.intellij.psi.PsiMember; -import com.intellij.psi.PsiModifier; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.java.kotlinSignature.KotlinSignatureAnnotation; - -public abstract class PsiMemberWrapper { - - @NotNull - protected final PsiMember psiMember; - - public PsiMemberWrapper(@NotNull PsiMember psiMember) { - this.psiMember = psiMember; - } - - @NotNull - public PsiMember getPsiMember() { - return psiMember; - } - - public boolean isStatic() { - return psiMember.hasModifierProperty(PsiModifier.STATIC); - } - - public boolean isPrivate() { - return psiMember.hasModifierProperty(PsiModifier.PRIVATE); - } - - public boolean isFinal() { - return psiMember.hasModifierProperty(PsiModifier.FINAL); - } - - public abstract boolean isAbstract(); - - public String getName() { - return psiMember.getName(); - } - - private KotlinSignatureAnnotation signatureAnnotation; - @NotNull - public KotlinSignatureAnnotation getSignatureAnnotation() { - if (signatureAnnotation == null) { - signatureAnnotation = KotlinSignatureAnnotation.get(getPsiMember()); - } - return signatureAnnotation; - } - - @Override - public String toString() { - return psiMember.getText(); - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java deleted file mode 100644 index d860a4a116b..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java +++ /dev/null @@ -1,59 +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.wrapper; - -import com.google.common.collect.Lists; -import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiModifier; -import com.intellij.psi.PsiParameter; -import com.intellij.psi.PsiType; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.util.List; - -public class PsiMethodWrapper extends PsiMemberWrapper { - - public PsiMethodWrapper(@NotNull PsiMethod psiMethod) { - super(psiMethod); - } - - private List parameters; - - @NotNull - public List getParameters() { - if (parameters == null) { - parameters = Lists.newArrayList(getPsiMethod().getParameterList().getParameters()); - } - return parameters; - } - - @Override - public boolean isAbstract() { - return psiMember.hasModifierProperty(PsiModifier.ABSTRACT); - } - - @NotNull - public PsiMethod getPsiMethod() { - return (PsiMethod) psiMember; - } - - @Nullable - public PsiType getReturnType() { - return getPsiMethod().getReturnType(); - } -}