@NotNull
public static JetExpression createStubExpressionOfNecessaryType(
@NotNull Project project, @NotNull JetType type, @NotNull BindingTrace trace) {
JetExpression expression = JetPsiFactory.createExpression(project, "$e");
trace.record(PROCESSED, expression);
trace.record(EXPRESSION_TYPE, expression, type);
return expression;
}
/**
* This method tries to resolve descriptors ambiguity between class descriptor and package
* descriptor for the same class. It's ok choose class for expression reference resolution.
*
* @return <code>true</code> if method has successfully resolved ambiguity
*/
private static boolean resolveClassPackageAmbiguity(
@NotNull Collection<DeclarationDescriptor> filteredDescriptors,
@NotNull JetSimpleNameExpression referenceExpression,
@NotNull JetScope resolutionScope,
@NotNull BindingTrace trace,
@NotNull JetScope scopeToCheckVisibility) {
if (filteredDescriptors.size() == 2) {
PackageViewDescriptor packageView = null;
ClassDescriptor classDescriptor = null;
for (DeclarationDescriptor filteredDescriptor : filteredDescriptors) {
if (filteredDescriptor instanceof PackageViewDescriptor) {
packageView = (PackageViewDescriptor) filteredDescriptor;
} else if (filteredDescriptor instanceof ClassDescriptor) {
classDescriptor = (ClassDescriptor) filteredDescriptor;
}
}
if (packageView != null && classDescriptor != null) {
if (packageView.getFqName().equalsTo(DescriptorUtils.getFqName(classDescriptor))) {
trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classDescriptor);
trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope);
checkVisibility(classDescriptor, trace, referenceExpression, scopeToCheckVisibility);
return true;
}
}
}
return false;
}
private static void recordConstructorDelegationCall(
@NotNull BindingTrace trace,
@NotNull ConstructorDescriptor constructor,
@NotNull ResolvedCall<?> call) {
//noinspection unchecked
trace.record(
CONSTRUCTOR_RESOLVED_DELEGATION_CALL,
constructor,
(ResolvedCall<ConstructorDescriptor>) call);
}
public static void recordFunctionDeclarationToDescriptor(
@NotNull BindingTrace trace,
@NotNull PsiElement psiElement,
@NotNull SimpleFunctionDescriptor function) {
if (function.getKind() != DECLARATION) {
throw new IllegalArgumentException(
"function of kind " + function.getKind() + " cannot have declaration");
}
trace.record(BindingContext.FUNCTION, psiElement, function);
}
@Nullable
public static JetType updateRecordedType(
@Nullable JetType type,
@NotNull JetExpression expression,
@NotNull BindingTrace trace,
boolean shouldBeMadeNullable) {
if (type == null) return null;
if (shouldBeMadeNullable) {
type = TypeUtils.makeNullable(type);
}
trace.record(BindingContext.EXPRESSION_TYPE, expression, type);
return type;
}
public static void reportAmbiguousLabel(
@NotNull BindingTrace trace,
@NotNull JetSimpleNameExpression targetLabel,
@NotNull Collection<DeclarationDescriptor> declarationsByLabel) {
Collection<PsiElement> targets = Lists.newArrayList();
for (DeclarationDescriptor descriptor : declarationsByLabel) {
PsiElement element = DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
assert element != null : "Label can only point to something in the same lexical scope";
targets.add(element);
}
if (!targets.isEmpty()) {
trace.record(AMBIGUOUS_LABEL_TARGET, targetLabel, targets);
}
trace.report(AMBIGUOUS_LABEL.on(targetLabel));
}
private static void storeResolutionResult(
@NotNull Collection<DeclarationDescriptor> descriptors,
@NotNull Collection<DeclarationDescriptor> canBeImportedDescriptors,
@NotNull JetSimpleNameExpression referenceExpression,
@NotNull Collection<JetScope> possibleResolutionScopes,
@NotNull BindingTrace trace,
@NotNull JetScope scopeToCheckVisibility) {
assert canBeImportedDescriptors.size() <= descriptors.size();
assert !possibleResolutionScopes.isEmpty();
// todo completion here needs all possible resolution scopes, if there are many
JetScope resolutionScope = possibleResolutionScopes.iterator().next();
// A special case - will fill all trace information
if (resolveClassPackageAmbiguity(
canBeImportedDescriptors,
referenceExpression,
resolutionScope,
trace,
scopeToCheckVisibility)) {
return;
}
// Simple case of no descriptors
if (descriptors.isEmpty()) {
trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope);
trace.report(UNRESOLVED_REFERENCE.on(referenceExpression, referenceExpression));
return;
}
// Decide if expression has resolved reference
DeclarationDescriptor descriptor = null;
if (descriptors.size() == 1) {
descriptor = descriptors.iterator().next();
assert canBeImportedDescriptors.size() <= 1;
} else if (canBeImportedDescriptors.size() == 1) {
descriptor = canBeImportedDescriptors.iterator().next();
}
if (descriptor != null) {
trace.record(
BindingContext.REFERENCE_TARGET, referenceExpression, descriptors.iterator().next());
trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope);
if (descriptor instanceof DeclarationDescriptorWithVisibility) {
checkVisibility(
(DeclarationDescriptorWithVisibility) descriptor,
trace,
referenceExpression,
scopeToCheckVisibility);
}
}
// Check for more information and additional errors
if (canBeImportedDescriptors.isEmpty()) {
assert descriptors.size() >= 1;
trace.report(CANNOT_BE_IMPORTED.on(referenceExpression, descriptors.iterator().next()));
return;
}
if (canBeImportedDescriptors.size() > 1) {
trace.record(BindingContext.AMBIGUOUS_REFERENCE_TARGET, referenceExpression, descriptors);
}
}