@NotNull
public Collection<? extends DeclarationDescriptor> lookupDescriptorsForUserType(
@NotNull JetUserType userType, @NotNull JetScope outerScope, @NotNull BindingTrace trace) {
if (userType.isAbsoluteInRootNamespace()) {
trace.report(Errors.UNSUPPORTED.on(userType, "package"));
return Collections.emptyList();
}
JetSimpleNameExpression referenceExpression = userType.getReferenceExpression();
if (referenceExpression == null) {
return Collections.emptyList();
}
JetUserType qualifier = userType.getQualifier();
if (qualifier == null) {
return lookupDescriptorsForSimpleNameReference(
referenceExpression, outerScope, outerScope, trace, LookupMode.ONLY_CLASSES, false, true);
}
Collection<? extends DeclarationDescriptor> declarationDescriptors =
lookupDescriptorsForUserType(qualifier, outerScope, trace);
return lookupSelectorDescriptors(
referenceExpression,
declarationDescriptors,
trace,
outerScope,
LookupMode.ONLY_CLASSES,
true);
}
// Temporary
// Returns true if deprecated constructor is in use, like
// ENTRY: Enum(arguments) instead of
// ENTRY(arguments)
public static boolean enumEntryUsesDeprecatedSuperConstructor(@NotNull JetEnumEntry enumEntry) {
JetInitializerList initializerList = enumEntry.getInitializerList();
if (initializerList == null || initializerList.getInitializers().isEmpty()) return false;
JetTypeReference typeReference = initializerList.getInitializers().get(0).getTypeReference();
if (typeReference == null) return false;
JetUserType userType = (JetUserType) typeReference.getTypeElement();
if (userType == null
|| userType.getReferenceExpression() instanceof JetEnumEntrySuperclassReferenceExpression)
return false;
return true;
}
@Nullable
public static Name getShortName(@NotNull JetAnnotationEntry annotation) {
JetTypeReference typeReference = annotation.getTypeReference();
assert typeReference != null : "Annotation entry hasn't typeReference " + annotation.getText();
JetTypeElement typeElement = typeReference.getTypeElement();
if (typeElement instanceof JetUserType) {
JetUserType userType = (JetUserType) typeElement;
String shortName = userType.getReferencedName();
if (shortName != null) {
return Name.identifier(shortName);
}
}
return null;
}
/** @return <code>null</code> iff the tye has syntactic errors */
@Nullable
public static FqName toQualifiedName(@NotNull JetUserType userType) {
List<String> reversedNames = Lists.newArrayList();
JetUserType current = userType;
while (current != null) {
String name = current.getReferencedName();
if (name == null) return null;
reversedNames.add(name);
current = current.getQualifier();
}
return FqName.fromSegments(ContainerUtil.reverse(reversedNames));
}
@NotNull
public Collection<DeclarationDescriptor> lookupDescriptorsForUserType(
@NotNull JetUserType userType,
@NotNull JetScope outerScope,
@NotNull BindingTrace trace,
boolean onlyClassifiers) {
if (userType.isAbsoluteInRootPackage()) {
trace.report(Errors.UNSUPPORTED.on(userType, "package"));
return Collections.emptyList();
}
JetSimpleNameExpression referenceExpression = userType.getReferenceExpression();
if (referenceExpression == null) {
return Collections.emptyList();
}
JetUserType qualifier = userType.getQualifier();
// We do not want to resolve the last segment of a user type to a package
JetScope filteredScope = filterOutPackagesIfNeeded(outerScope, onlyClassifiers);
if (qualifier == null) {
return lookupDescriptorsForSimpleNameReference(
referenceExpression,
filteredScope,
outerScope,
trace,
LookupMode.ONLY_CLASSES_AND_PACKAGES,
false,
true);
}
Collection<DeclarationDescriptor> declarationDescriptors =
lookupDescriptorsForUserType(qualifier, outerScope, trace, false);
return lookupSelectorDescriptors(
referenceExpression,
declarationDescriptors,
trace,
filteredScope,
LookupMode.ONLY_CLASSES_AND_PACKAGES,
true);
}