protected void checkFunction(
JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) {
reportErrorIfHasIllegalModifier(function);
DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration();
boolean hasAbstractModifier = function.hasModifier(JetTokens.ABSTRACT_KEYWORD);
checkDeclaredTypeInPublicMember(function, functionDescriptor);
if (containingDescriptor instanceof ClassDescriptor) {
ClassDescriptor classDescriptor = (ClassDescriptor) containingDescriptor;
boolean inTrait = classDescriptor.getKind() == ClassKind.INTERFACE;
if (hasAbstractModifier && !classCanHaveAbstractMembers(classDescriptor)) {
trace.report(
ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(
function, functionDescriptor.getName().asString(), classDescriptor));
}
if (hasAbstractModifier && inTrait) {
trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(function));
}
boolean hasBody = function.hasBody();
if (hasBody && hasAbstractModifier) {
trace.report(ABSTRACT_FUNCTION_WITH_BODY.on(function, functionDescriptor));
}
if (!hasBody && function.hasModifier(JetTokens.FINAL_KEYWORD) && inTrait) {
trace.report(FINAL_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor));
}
if (!hasBody && !hasAbstractModifier && !inTrait) {
trace.report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor));
}
return;
}
modifiersChecker.reportIllegalModalityModifiers(function);
if (!function.hasBody() && !hasAbstractModifier) {
trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor));
}
}
private static void addResultsForClass(
@NotNull @Mutable Set<LookupResult> results,
@NotNull JetSimpleNameExpression selector,
@NotNull LookupMode lookupMode,
@NotNull ClassDescriptor descriptor) {
JetScope scope =
lookupMode == LookupMode.ONLY_CLASSES_AND_PACKAGES
? descriptor.getUnsubstitutedInnerClassesScope()
: descriptor.getDefaultType().getMemberScope();
results.add(lookupSimpleNameReference(selector, scope, lookupMode, false));
results.add(lookupSimpleNameReference(selector, descriptor.getStaticScope(), lookupMode, true));
}
private void checkEnumEntry(
@NotNull JetEnumEntry enumEntry, @NotNull ClassDescriptor classDescriptor) {
DeclarationDescriptor declaration = classDescriptor.getContainingDeclaration();
assert DescriptorUtils.isEnumClass(declaration)
: "Enum entry should be declared in enum class: " + classDescriptor;
ClassDescriptor enumClass = (ClassDescriptor) declaration;
if (enumEntryUsesDeprecatedSuperConstructor(enumEntry)) {
trace.report(
Errors.ENUM_ENTRY_USES_DEPRECATED_SUPER_CONSTRUCTOR.on(enumEntry, classDescriptor));
}
String neededDelimiter = enumEntryExpectedDelimiter(enumEntry);
if (!neededDelimiter.isEmpty()) {
trace.report(
Errors.ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER.on(
enumEntry, classDescriptor, neededDelimiter));
}
if (enumEntryAfterEnumMember(enumEntry)) {
trace.report(Errors.ENUM_ENTRY_AFTER_ENUM_MEMBER.on(enumEntry, classDescriptor));
}
List<JetDelegationSpecifier> delegationSpecifiers = enumEntry.getDelegationSpecifiers();
ConstructorDescriptor constructor = enumClass.getUnsubstitutedPrimaryConstructor();
if ((constructor == null || !constructor.getValueParameters().isEmpty())
&& delegationSpecifiers.isEmpty()) {
trace.report(ENUM_ENTRY_SHOULD_BE_INITIALIZED.on(enumEntry, enumClass));
}
for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
JetTypeReference typeReference = delegationSpecifier.getTypeReference();
if (typeReference != null) {
JetType type = trace.getBindingContext().get(TYPE, typeReference);
if (type != null) {
JetType enumType = enumClass.getDefaultType();
if (!type.getConstructor().equals(enumType.getConstructor())) {
trace.report(ENUM_ENTRY_ILLEGAL_TYPE.on(typeReference, enumClass));
}
}
}
}
}
private void checkSupertypesForConsistency(@NotNull ClassDescriptor classDescriptor) {
Multimap<TypeConstructor, TypeProjection> multimap =
SubstitutionUtils.buildDeepSubstitutionMultimap(classDescriptor.getDefaultType());
for (Map.Entry<TypeConstructor, Collection<TypeProjection>> entry :
multimap.asMap().entrySet()) {
Collection<TypeProjection> projections = entry.getValue();
if (projections.size() > 1) {
TypeConstructor typeConstructor = entry.getKey();
DeclarationDescriptor declarationDescriptor = typeConstructor.getDeclarationDescriptor();
assert declarationDescriptor instanceof TypeParameterDescriptor : declarationDescriptor;
TypeParameterDescriptor typeParameterDescriptor =
(TypeParameterDescriptor) declarationDescriptor;
// Immediate arguments of supertypes cannot be projected
Set<JetType> conflictingTypes = Sets.newLinkedHashSet();
for (TypeProjection projection : projections) {
conflictingTypes.add(projection.getType());
}
removeDuplicateTypes(conflictingTypes);
if (conflictingTypes.size() > 1) {
DeclarationDescriptor containingDeclaration =
typeParameterDescriptor.getContainingDeclaration();
assert containingDeclaration instanceof ClassDescriptor : containingDeclaration;
JetClassOrObject psiElement =
(JetClassOrObject) DescriptorToSourceUtils.getSourceFromDescriptor(classDescriptor);
assert psiElement != null;
JetDelegationSpecifierList delegationSpecifierList =
psiElement.getDelegationSpecifierList();
assert delegationSpecifierList != null;
//
// trace.getErrorHandler().genericError(delegationSpecifierList.getNode(), "Type parameter
// " + typeParameterDescriptor.getName() + " of " + containingDeclaration.getName() + "
// has inconsistent values: " + conflictingTypes);
trace.report(
INCONSISTENT_TYPE_PARAMETER_VALUES.on(
delegationSpecifierList,
typeParameterDescriptor,
(ClassDescriptor) containingDeclaration,
conflictingTypes));
}
}
}
}
private void checkPropertyAbstractness(
@NotNull JetProperty property,
@NotNull PropertyDescriptor propertyDescriptor,
@NotNull ClassDescriptor classDescriptor) {
JetPropertyAccessor getter = property.getGetter();
JetPropertyAccessor setter = property.getSetter();
JetModifierList modifierList = property.getModifierList();
ASTNode abstractNode =
modifierList != null ? modifierList.getModifierNode(JetTokens.ABSTRACT_KEYWORD) : null;
if (abstractNode != null) { // has abstract modifier
if (!classCanHaveAbstractMembers(classDescriptor)) {
String name = property.getName();
trace.report(
ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(
property, name != null ? name : "", classDescriptor));
return;
}
if (classDescriptor.getKind() == ClassKind.INTERFACE) {
trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(property));
}
}
if (propertyDescriptor.getModality() == Modality.ABSTRACT) {
JetExpression initializer = property.getInitializer();
if (initializer != null) {
trace.report(ABSTRACT_PROPERTY_WITH_INITIALIZER.on(initializer));
}
JetPropertyDelegate delegate = property.getDelegate();
if (delegate != null) {
trace.report(ABSTRACT_DELEGATED_PROPERTY.on(delegate));
}
if (getter != null && getter.hasBody()) {
trace.report(ABSTRACT_PROPERTY_WITH_GETTER.on(getter));
}
if (setter != null && setter.hasBody()) {
trace.report(ABSTRACT_PROPERTY_WITH_SETTER.on(setter));
}
}
}
private void checkPrimaryConstructor(
JetClassOrObject classOrObject, ClassDescriptor classDescriptor) {
ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
JetPrimaryConstructor declaration = classOrObject.getPrimaryConstructor();
if (primaryConstructor == null || declaration == null) return;
for (JetParameter parameter : declaration.getValueParameters()) {
PropertyDescriptor propertyDescriptor =
trace.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
if (propertyDescriptor != null) {
modifiersChecker.checkModifiersForDeclaration(parameter, propertyDescriptor);
}
}
if (declaration.getModifierList() != null && !declaration.hasConstructorKeyword()) {
trace.report(MISSING_CONSTRUCTOR_KEYWORD.on(declaration.getModifierList()));
}
if (!(classOrObject instanceof JetClass)) {
trace.report(CONSTRUCTOR_IN_OBJECT.on(declaration));
}
checkConstructorDeclaration(primaryConstructor, declaration);
}
// Returns a set of enum or sealed types of which supertypeOwner is an entry or a member
@NotNull
private static Set<TypeConstructor> getAllowedFinalSupertypes(
@NotNull ClassDescriptor descriptor, @NotNull JetClassOrObject jetClass) {
Set<TypeConstructor> parentEnumOrSealed;
if (jetClass instanceof JetEnumEntry) {
parentEnumOrSealed =
Collections.singleton(
((ClassDescriptor) descriptor.getContainingDeclaration()).getTypeConstructor());
} else {
parentEnumOrSealed = Collections.emptySet();
ClassDescriptor currentDescriptor = descriptor;
while (currentDescriptor.getContainingDeclaration() instanceof ClassDescriptor) {
currentDescriptor = (ClassDescriptor) currentDescriptor.getContainingDeclaration();
if (currentDescriptor.getModality() == Modality.SEALED) {
if (parentEnumOrSealed.isEmpty()) {
parentEnumOrSealed = new HashSet<TypeConstructor>();
}
parentEnumOrSealed.add(currentDescriptor.getTypeConstructor());
}
}
}
return parentEnumOrSealed;
}
public static boolean canAllUnderImportFromClass(@NotNull ClassDescriptor descriptor) {
return !descriptor.getKind().isSingleton();
}
private void checkSupertypeList(
@NotNull ClassDescriptor supertypeOwner,
@NotNull Map<JetTypeReference, JetType> supertypes,
@NotNull JetClassOrObject jetClass) {
Set<TypeConstructor> allowedFinalSupertypes =
getAllowedFinalSupertypes(supertypeOwner, jetClass);
Set<TypeConstructor> typeConstructors = Sets.newHashSet();
boolean classAppeared = false;
for (Map.Entry<JetTypeReference, JetType> entry : supertypes.entrySet()) {
JetTypeReference typeReference = entry.getKey();
JetType supertype = entry.getValue();
boolean addSupertype = true;
ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
if (classDescriptor != null) {
if (ErrorUtils.isError(classDescriptor)) continue;
if (classDescriptor.getKind() != ClassKind.INTERFACE) {
if (supertypeOwner.getKind() == ClassKind.ENUM_CLASS) {
trace.report(CLASS_IN_SUPERTYPE_FOR_ENUM.on(typeReference));
addSupertype = false;
} else if (supertypeOwner.getKind() == ClassKind.INTERFACE
&& !classAppeared
&& !TypesPackage.isDynamic(supertype) /* avoid duplicate diagnostics */) {
trace.report(TRAIT_WITH_SUPERCLASS.on(typeReference));
addSupertype = false;
}
if (classAppeared) {
trace.report(MANY_CLASSES_IN_SUPERTYPE_LIST.on(typeReference));
} else {
classAppeared = true;
}
}
} else {
trace.report(SUPERTYPE_NOT_A_CLASS_OR_TRAIT.on(typeReference));
}
TypeConstructor constructor = supertype.getConstructor();
if (addSupertype && !typeConstructors.add(constructor)) {
trace.report(SUPERTYPE_APPEARS_TWICE.on(typeReference));
}
if (DescriptorUtils.isSingleton(classDescriptor)) {
trace.report(SINGLETON_IN_SUPERTYPE.on(typeReference));
} else if (constructor.isFinal() && !allowedFinalSupertypes.contains(constructor)) {
if (classDescriptor.getModality() == Modality.SEALED) {
DeclarationDescriptor containingDescriptor = supertypeOwner.getContainingDeclaration();
while (containingDescriptor != null && containingDescriptor != classDescriptor) {
containingDescriptor = containingDescriptor.getContainingDeclaration();
}
if (containingDescriptor == null) {
trace.report(SEALED_SUPERTYPE.on(typeReference));
} else {
trace.report(SEALED_SUPERTYPE_IN_LOCAL_CLASS.on(typeReference));
}
} else {
trace.report(FINAL_SUPERTYPE.on(typeReference));
}
}
}
}