public static void reportCyclicInheritanceHierarchyError(
@NotNull BindingTrace trace,
@NotNull ClassDescriptor classDescriptor,
@NotNull ClassDescriptor superclass) {
PsiElement psiElement =
BindingContextUtils.classDescriptorToDeclaration(
trace.getBindingContext(), classDescriptor);
PsiElement elementToMark = null;
if (psiElement instanceof JetClassOrObject) {
JetClassOrObject classOrObject = (JetClassOrObject) psiElement;
for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
JetTypeReference typeReference = delegationSpecifier.getTypeReference();
if (typeReference == null) continue;
JetType supertype = trace.get(TYPE, typeReference);
if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) {
elementToMark = typeReference;
}
}
}
if (elementToMark == null && psiElement instanceof PsiNameIdentifierOwner) {
PsiNameIdentifierOwner namedElement = (PsiNameIdentifierOwner) psiElement;
PsiElement nameIdentifier = namedElement.getNameIdentifier();
if (nameIdentifier != null) {
elementToMark = nameIdentifier;
}
}
if (elementToMark != null) {
trace.report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark));
}
}
@NotNull
private Collection<PsiElement> getDeclarationsByDescriptor(
@NotNull DeclarationDescriptor declarationDescriptor) {
Collection<PsiElement> declarations;
if (declarationDescriptor instanceof PackageViewDescriptor) {
final PackageViewDescriptor aPackage = (PackageViewDescriptor) declarationDescriptor;
Collection<JetFile> files = trace.get(BindingContext.PACKAGE_TO_FILES, aPackage.getFqName());
if (files == null) {
return Collections
.emptyList(); // package can be defined out of Kotlin sources, e. g. in library or Java
// code
}
declarations =
Collections2.transform(
files,
new Function<JetFile, PsiElement>() {
@Override
public PsiElement apply(@Nullable JetFile file) {
assert file != null : "File is null for aPackage " + aPackage;
return file.getPackageDirective().getNameIdentifier();
}
});
} else {
declarations =
Collections.singletonList(
BindingContextUtils.descriptorToDeclaration(
trace.getBindingContext(), declarationDescriptor));
}
return declarations;
}
private void reportRedeclarations(@NotNull Multimap<Name, DeclarationDescriptor> descriptorMap) {
Set<Pair<PsiElement, Name>> redeclarations = Sets.newHashSet();
for (Name name : descriptorMap.keySet()) {
Collection<DeclarationDescriptor> descriptors = descriptorMap.get(name);
if (descriptors.size() > 1) {
// We mustn't compare PropertyDescriptor with PropertyDescriptor because we do this at
// OverloadResolver
for (DeclarationDescriptor descriptor : descriptors) {
if (descriptor instanceof ClassDescriptor) {
for (DeclarationDescriptor descriptor2 : descriptors) {
if (descriptor == descriptor2) {
continue;
}
redeclarations.add(
Pair.create(
BindingContextUtils.classDescriptorToDeclaration(
trace.getBindingContext(), (ClassDescriptor) descriptor),
descriptor.getName()));
if (descriptor2 instanceof PropertyDescriptor) {
redeclarations.add(
Pair.create(
BindingContextUtils.descriptorToDeclaration(
trace.getBindingContext(), descriptor2),
descriptor2.getName()));
}
}
}
}
}
}
for (Pair<PsiElement, Name> redeclaration : redeclarations) {
trace.report(
REDECLARATION.on(redeclaration.getFirst(), redeclaration.getSecond().asString()));
}
}
@NotNull
private static AnonymousFunctionDescriptor createFunctionDescriptor(
@NotNull JetFunctionLiteralExpression expression,
@NotNull ExpressionTypingContext context,
boolean functionTypeExpected) {
JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef();
AnonymousFunctionDescriptor functionDescriptor =
new AnonymousFunctionDescriptor(
context.scope.getContainingDeclaration(),
Collections.<AnnotationDescriptor>emptyList(),
CallableMemberDescriptor.Kind.DECLARATION);
List<ValueParameterDescriptor> valueParameterDescriptors =
createValueParameterDescriptors(
context, functionLiteral,
functionDescriptor, functionTypeExpected);
JetType effectiveReceiverType;
if (receiverTypeRef == null) {
if (functionTypeExpected) {
effectiveReceiverType = KotlinBuiltIns.getInstance().getReceiverType(context.expectedType);
} else {
effectiveReceiverType = null;
}
} else {
effectiveReceiverType =
context
.expressionTypingServices
.getTypeResolver()
.resolveType(context.scope, receiverTypeRef, context.trace, true);
}
functionDescriptor.initialize(
effectiveReceiverType,
ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER,
Collections.<TypeParameterDescriptorImpl>emptyList(),
valueParameterDescriptors,
/*unsubstitutedReturnType = */ null,
Modality.FINAL,
Visibilities.LOCAL);
BindingContextUtils.recordFunctionDeclarationToDescriptor(
context.trace, functionLiteral, functionDescriptor);
return functionDescriptor;
}