@NotNull
private JetScope getAppropriateScope(
@NotNull ClassDescriptor classDescriptor, @NotNull LookupMode lookupMode) {
return lookupMode == LookupMode.ONLY_CLASSES
? classDescriptor.getUnsubstitutedInnerClassesScope()
: classDescriptor.getDefaultType().getMemberScope();
}
// allowedFinalSupertypes typically contains a enum type of which supertypeOwner is an entry
private void checkSupertypeList(
@NotNull MutableClassDescriptor supertypeOwner,
@NotNull Map<JetTypeReference, JetType> supertypes,
Set<TypeConstructor> allowedFinalSupertypes) {
Set<TypeConstructor> typeConstructors = Sets.newHashSet();
boolean classAppeared = false;
for (Map.Entry<JetTypeReference, JetType> entry : supertypes.entrySet()) {
JetTypeReference typeReference = entry.getKey();
JetType supertype = entry.getValue();
ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
if (classDescriptor != null) {
if (classDescriptor.getKind() != ClassKind.TRAIT) {
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 (!typeConstructors.add(constructor)) {
trace.report(SUPERTYPE_APPEARS_TWICE.on(typeReference));
}
if (constructor.isSealed() && !allowedFinalSupertypes.contains(constructor)) {
trace.report(FINAL_SUPERTYPE.on(typeReference));
}
}
}
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 MutableClassDescriptor createSyntheticClassObject(
@NotNull ClassDescriptor classDescriptor) {
MutableClassDescriptor classObject =
new MutableClassDescriptor(
classDescriptor,
outerScope,
ClassKind.CLASS_OBJECT,
false,
getClassObjectName(classDescriptor.getName()));
classObject.setModality(Modality.FINAL);
classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility());
classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
createPrimaryConstructorForObject(null, classObject);
return classObject;
}
@NotNull
/*package*/ OverloadResolutionResultsImpl<FunctionDescriptor> resolveFunctionCall(
@NotNull BasicCallResolutionContext context) {
ProgressIndicatorProvider.checkCanceled();
List<ResolutionTask<CallableDescriptor, FunctionDescriptor>> prioritizedTasks;
JetExpression calleeExpression = context.call.getCalleeExpression();
JetReferenceExpression functionReference;
if (calleeExpression instanceof JetSimpleNameExpression) {
JetSimpleNameExpression expression = (JetSimpleNameExpression) calleeExpression;
functionReference = expression;
ExpressionTypingUtils.checkCapturingInClosure(expression, context.trace, context.scope);
Name name = expression.getReferencedNameAsName();
prioritizedTasks =
TaskPrioritizer.<CallableDescriptor, FunctionDescriptor>computePrioritizedTasks(
context,
name,
functionReference,
CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES);
ResolutionTask.DescriptorCheckStrategy abstractConstructorCheck =
new ResolutionTask.DescriptorCheckStrategy() {
@Override
public <D extends CallableDescriptor> boolean performAdvancedChecks(
D descriptor, BindingTrace trace, TracingStrategy tracing) {
if (descriptor instanceof ConstructorDescriptor) {
Modality modality =
((ConstructorDescriptor) descriptor).getContainingDeclaration().getModality();
if (modality == Modality.ABSTRACT) {
tracing.instantiationOfAbstractClass(trace);
return false;
}
}
return true;
}
};
for (ResolutionTask task : prioritizedTasks) {
task.setCheckingStrategy(abstractConstructorCheck);
}
} else {
JetValueArgumentList valueArgumentList = context.call.getValueArgumentList();
PsiElement reportAbsenceOn =
valueArgumentList == null ? context.call.getCallElement() : valueArgumentList;
if (calleeExpression instanceof JetConstructorCalleeExpression) {
assert !context.call.getExplicitReceiver().exists();
JetConstructorCalleeExpression expression =
(JetConstructorCalleeExpression) calleeExpression;
functionReference = expression.getConstructorReferenceExpression();
if (functionReference == null) {
return checkArgumentTypesAndFail(context); // No type there
}
JetTypeReference typeReference = expression.getTypeReference();
assert typeReference != null;
JetType constructedType =
typeResolver.resolveType(context.scope, typeReference, context.trace, true);
if (constructedType.isError()) {
return checkArgumentTypesAndFail(context);
}
DeclarationDescriptor declarationDescriptor =
constructedType.getConstructor().getDeclarationDescriptor();
if (declarationDescriptor instanceof ClassDescriptor) {
ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
Collection<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
if (constructors.isEmpty()) {
context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
return checkArgumentTypesAndFail(context);
}
Collection<ResolutionCandidate<CallableDescriptor>> candidates =
TaskPrioritizer.<CallableDescriptor>convertWithImpliedThis(
context.scope,
Collections.<ReceiverValue>singletonList(NO_RECEIVER),
constructors);
prioritizedTasks =
TaskPrioritizer
.<CallableDescriptor, FunctionDescriptor>computePrioritizedTasksFromCandidates(
context, functionReference, candidates, null);
} else {
context.trace.report(NOT_A_CLASS.on(calleeExpression));
return checkArgumentTypesAndFail(context);
}
} else if (calleeExpression instanceof JetThisReferenceExpression) {
functionReference = (JetThisReferenceExpression) calleeExpression;
DeclarationDescriptor containingDeclaration = context.scope.getContainingDeclaration();
if (containingDeclaration instanceof ConstructorDescriptor) {
containingDeclaration = containingDeclaration.getContainingDeclaration();
}
assert containingDeclaration instanceof ClassDescriptor;
ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
Collection<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
if (constructors.isEmpty()) {
context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
return checkArgumentTypesAndFail(context);
}
List<ResolutionCandidate<CallableDescriptor>> candidates =
ResolutionCandidate.<CallableDescriptor>convertCollection(
constructors, JetPsiUtil.isSafeCall(context.call));
prioritizedTasks =
Collections.singletonList(
new ResolutionTask<CallableDescriptor, FunctionDescriptor>(
candidates, functionReference, context)); // !! DataFlowInfo.EMPTY
} else if (calleeExpression != null) {
// Here we handle the case where the callee expression must be something of type function,
// e.g. (foo.bar())(1, 2)
JetType calleeType =
expressionTypingServices.safeGetType(
context.scope,
calleeExpression,
NO_EXPECTED_TYPE,
context.dataFlowInfo,
context
.trace); // We are actually expecting a function, but there seems to be no easy
// way of expressing this
if (!KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(calleeType)) {
// checkTypesWithNoCallee(trace, scope, call);
if (!calleeType.isError()) {
context.trace.report(CALLEE_NOT_A_FUNCTION.on(calleeExpression, calleeType));
}
return checkArgumentTypesAndFail(context);
}
FunctionDescriptorImpl functionDescriptor =
new ExpressionAsFunctionDescriptor(
context.scope.getContainingDeclaration(),
Name.special("<for expression " + calleeExpression.getText() + ">"),
calleeExpression);
FunctionDescriptorUtil.initializeFromFunctionType(
functionDescriptor,
calleeType,
NO_RECEIVER_PARAMETER,
Modality.FINAL,
Visibilities.LOCAL);
ResolutionCandidate<CallableDescriptor> resolutionCandidate =
ResolutionCandidate.<CallableDescriptor>create(
functionDescriptor, JetPsiUtil.isSafeCall(context.call));
resolutionCandidate.setReceiverArgument(context.call.getExplicitReceiver());
resolutionCandidate.setExplicitReceiverKind(ExplicitReceiverKind.RECEIVER_ARGUMENT);
// strictly speaking, this is a hack:
// we need to pass a reference, but there's no reference in the PSI,
// so we wrap what we have into a fake reference and pass it on (unwrap on the other end)
functionReference = new JetFakeReference(calleeExpression);
prioritizedTasks =
Collections.singletonList(
new ResolutionTask<CallableDescriptor, FunctionDescriptor>(
Collections.singleton(resolutionCandidate), functionReference, context));
} else {
// checkTypesWithNoCallee(trace, scope, call);
return checkArgumentTypesAndFail(context);
}
}
return doResolveCallOrGetCachedResults(
ResolutionResultsCache.FUNCTION_MEMBER_TYPE,
context,
prioritizedTasks,
CallTransformer.FUNCTION_CALL_TRANSFORMER,
functionReference);
}