001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.load.java.components;
018
019 import kotlin.Unit;
020 import kotlin.jvm.functions.Function1;
021 import org.jetbrains.annotations.NotNull;
022 import org.jetbrains.annotations.Nullable;
023 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
024 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
025 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor;
026 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
027 import org.jetbrains.kotlin.load.java.structure.*;
028 import org.jetbrains.kotlin.name.FqName;
029 import org.jetbrains.kotlin.name.Name;
030 import org.jetbrains.kotlin.resolve.NonReportingOverrideStrategy;
031 import org.jetbrains.kotlin.resolve.OverridingUtil;
032 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter;
033
034 import java.util.Collection;
035 import java.util.LinkedHashSet;
036 import java.util.List;
037 import java.util.Set;
038
039 public final class DescriptorResolverUtils {
040 private DescriptorResolverUtils() {
041 }
042
043 @NotNull
044 public static <D extends CallableMemberDescriptor> Collection<D> resolveOverridesForNonStaticMembers(
045 @NotNull Name name, @NotNull Collection<D> membersFromSupertypes, @NotNull Collection<D> membersFromCurrent,
046 @NotNull ClassDescriptor classDescriptor, @NotNull ErrorReporter errorReporter
047 ) {
048 return resolveOverrides(name, membersFromSupertypes, membersFromCurrent, classDescriptor, errorReporter, false);
049 }
050
051 @NotNull
052 public static <D extends CallableMemberDescriptor> Collection<D> resolveOverridesForStaticMembers(
053 @NotNull Name name, @NotNull Collection<D> membersFromSupertypes, @NotNull Collection<D> membersFromCurrent,
054 @NotNull ClassDescriptor classDescriptor, @NotNull ErrorReporter errorReporter
055 ) {
056 return resolveOverrides(name, membersFromSupertypes, membersFromCurrent, classDescriptor, errorReporter, true);
057 }
058
059 @NotNull
060 private static <D extends CallableMemberDescriptor> Collection<D> resolveOverrides(
061 @NotNull Name name,
062 @NotNull Collection<D> membersFromSupertypes,
063 @NotNull Collection<D> membersFromCurrent,
064 @NotNull ClassDescriptor classDescriptor,
065 @NotNull final ErrorReporter errorReporter,
066 final boolean isStaticContext
067 ) {
068 final Set<D> result = new LinkedHashSet<D>();
069
070 OverridingUtil.generateOverridesInFunctionGroup(
071 name, membersFromSupertypes, membersFromCurrent, classDescriptor,
072 new NonReportingOverrideStrategy() {
073 @Override
074 @SuppressWarnings("unchecked")
075 public void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride) {
076 OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, new Function1<CallableMemberDescriptor, Unit>() {
077 @Override
078 public Unit invoke(@NotNull CallableMemberDescriptor descriptor) {
079 errorReporter.reportCannotInferVisibility(descriptor);
080 return Unit.INSTANCE;
081 }
082 });
083 result.add((D) fakeOverride);
084 }
085
086 @Override
087 public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) {
088 // nop
089 }
090
091 @Override
092 public void setOverriddenDescriptors(
093 @NotNull CallableMemberDescriptor member, @NotNull Collection<? extends CallableMemberDescriptor> overridden
094 ) {
095 // do not set overridden descriptors for declared static fields and methods from java
096 if (isStaticContext && member.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
097 return;
098 }
099 super.setOverriddenDescriptors(member, overridden);
100 }
101 }
102 );
103
104 return result;
105 }
106
107 @Nullable
108 public static ValueParameterDescriptor getAnnotationParameterByName(@NotNull Name name, @NotNull ClassDescriptor annotationClass) {
109 Collection<ConstructorDescriptor> constructors = annotationClass.getConstructors();
110 if (constructors.size() != 1) return null;
111
112 for (ValueParameterDescriptor parameter : constructors.iterator().next().getValueParameters()) {
113 if (parameter.getName().equals(name)) {
114 return parameter;
115 }
116 }
117
118 return null;
119 }
120
121 public static boolean isObjectMethodInInterface(@NotNull JavaMember member) {
122 return member.getContainingClass().isInterface() && member instanceof JavaMethod && isObjectMethod((JavaMethod) member);
123 }
124
125 public static boolean isObjectMethod(@NotNull JavaMethod method) {
126 String name = method.getName().asString();
127 if (name.equals("toString") || name.equals("hashCode")) {
128 return method.getValueParameters().isEmpty();
129 }
130 else if (name.equals("equals")) {
131 return isMethodWithOneParameterWithFqName(method, "java.lang.Object");
132 }
133 return false;
134 }
135
136 private static boolean isMethodWithOneParameterWithFqName(@NotNull JavaMethod method, @NotNull String fqName) {
137 List<JavaValueParameter> parameters = method.getValueParameters();
138 if (parameters.size() == 1) {
139 JavaType type = parameters.get(0).getType();
140 if (type instanceof JavaClassifierType) {
141 JavaClassifier classifier = ((JavaClassifierType) type).getClassifier();
142 if (classifier instanceof JavaClass) {
143 FqName classFqName = ((JavaClass) classifier).getFqName();
144 return classFqName != null && classFqName.asString().equals(fqName);
145 }
146 }
147 }
148 return false;
149 }
150 }