@Override
public void replaceDotToken(PsiElement newDot) {
if (newDot == null) return;
if (!TokenSets.DOTS.contains(newDot.getNode().getElementType())) return;
final PsiElement oldDot = getDotToken();
if (oldDot == null) return;
getNode().replaceChild(oldDot.getNode(), newDot.getNode());
}
private static PsiType doFun(GrReferenceExpression refExpr) {
if (ResolveUtil.isClassReference(refExpr)) {
GrExpression qualifier = refExpr.getQualifier();
LOG.assertTrue(qualifier != null);
return TypesUtil.createJavaLangClassType(
qualifier.getType(), refExpr.getProject(), refExpr.getResolveScope());
}
if (PsiUtil.isCompileStatic(refExpr)) {
final GroovyResolveResult resolveResult = refExpr.advancedResolve();
final PsiElement resolvedF = resolveResult.getElement();
final PsiType type;
if (resolvedF instanceof GrField) {
type = ((GrField) resolvedF).getType();
} else if (resolvedF instanceof GrAccessorMethod) {
type = ((GrAccessorMethod) resolvedF).getProperty().getType();
} else {
type = null;
}
if (type != null) {
return resolveResult.getSubstitutor().substitute(type);
}
}
final PsiElement resolved = refExpr.resolve();
final PsiType nominal = refExpr.getNominalType();
Boolean reassigned = GrReassignedLocalVarsChecker.isReassignedVar(refExpr);
if (reassigned != null && reassigned.booleanValue()) {
return GrReassignedLocalVarsChecker.getReassignedVarType(refExpr, true);
}
final PsiType inferred = getInferredTypes(refExpr, resolved);
if (inferred == null) {
if (nominal == null) {
// inside nested closure we could still try to infer from variable initializer. Not sound,
// but makes sense
if (resolved instanceof GrVariable) {
LOG.assertTrue(resolved.isValid());
return ((GrVariable) resolved).getTypeGroovy();
}
}
return nominal;
}
if (nominal == null) return inferred;
if (!TypeConversionUtil.isAssignable(TypeConversionUtil.erasure(nominal), inferred, false)) {
if (resolved instanceof GrVariable
&& ((GrVariable) resolved).getTypeElementGroovy() != null) {
return nominal;
}
}
return inferred;
}
@Override
public PsiElement handleElementRenameSimple(String newElementName)
throws IncorrectOperationException {
if (!PsiUtil.isValidReferenceName(newElementName)) {
final PsiElement old = getReferenceNameElement();
if (old == null) throw new IncorrectOperationException("ref has no name element");
PsiElement element =
GroovyPsiElementFactory.getInstance(getProject())
.createStringLiteralForReference(newElementName);
old.replace(element);
return this;
}
return super.handleElementRenameSimple(newElementName);
}
@Override
@Nullable
public String getReferenceName() {
PsiElement nameElement = getReferenceNameElement();
if (nameElement != null) {
IElementType nodeType = nameElement.getNode().getElementType();
if (TokenSets.STRING_LITERAL_SET.contains(nodeType)) {
final Object value = GrLiteralImpl.getLiteralValue(nameElement);
if (value instanceof String) {
return (String) value;
}
}
return nameElement.getText();
}
return null;
}
private static void assertAllAreValid(@NotNull GroovyResolveResult[] candidates) {
for (GroovyResolveResult candidate : candidates) {
final PsiElement element = candidate.getElement();
LOG.assertTrue(element == null || element.isValid());
}
}
@NotNull
private GroovyResolveResult[] resolveTypeOrPropertyInner() {
PsiElement nameElement = getReferenceNameElement();
String name = getReferenceName();
if (name == null || nameElement == null) return GroovyResolveResult.EMPTY_ARRAY;
IElementType nameType = nameElement.getNode().getElementType();
if (nameType == GroovyTokenTypes.kTHIS) {
GroovyResolveResult[] results = GrThisReferenceResolver.resolveThisExpression(this);
if (results != null) {
return results;
}
} else if (nameType == GroovyTokenTypes.kSUPER) {
GroovyResolveResult[] results = GrSuperReferenceResolver.resolveSuperExpression(this);
if (results != null) {
return results;
}
}
EnumSet<ClassHint.ResolveKind> kinds =
getParent() instanceof GrReferenceExpression
? ClassHint.RESOLVE_KINDS_CLASS_PACKAGE
: ClassHint.RESOLVE_KINDS_CLASS;
GroovyResolveResult[] classCandidates = null;
GrReferenceResolveRunner resolveRunner = new GrReferenceResolveRunner(this);
ResolverProcessor processor = new PropertyResolverProcessor(name, this);
resolveRunner.resolveImpl(processor);
final GroovyResolveResult[] fieldCandidates = processor.getCandidates();
if (hasAt()) {
return fieldCandidates;
}
boolean canBeClassOrPackage = ResolveUtil.canBeClassOrPackage(this);
if (canBeClassOrPackage && findClassOrPackageAtFirst()) {
ResolverProcessor classProcessor = new ClassResolverProcessor(name, this, kinds);
resolveRunner.resolveImpl(classProcessor);
classCandidates = classProcessor.getCandidates();
if (classCandidates.length > 0 && containsPackage(classCandidates)) {
final PsiElement firstNonReferenceExprParent =
PsiTreeUtil.skipParentsOfType(this, GrReferenceExpressionImpl.class);
final GrReferenceExpressionImpl topRef =
(GrReferenceExpressionImpl)
PsiTreeUtil.findFirstParent(
this,
new Condition<PsiElement>() {
@Override
public boolean value(PsiElement parent) {
return parent.getParent() == firstNonReferenceExprParent
&& parent instanceof GrReferenceExpressionImpl;
}
});
if (topRef != null) {
final String fqn = topRef.getTextSkipWhiteSpaceAndComments();
if (JavaPsiFacade.getInstance(getProject()).findClass(fqn, getResolveScope()) != null) {
return classCandidates;
}
}
}
}
// if reference expression is in class we need to return field instead of accessor method
for (GroovyResolveResult candidate : fieldCandidates) {
final PsiElement element = candidate.getElement();
if (element instanceof PsiField) {
final PsiClass containingClass = ((PsiField) element).getContainingClass();
if (containingClass != null && PsiUtil.getContextClass(this) == containingClass)
return fieldCandidates;
} else if (!(element instanceof GrBindingVariable)) {
return fieldCandidates;
}
}
if (classCandidates != null && classCandidates.length > 0) return classCandidates;
final boolean isLValue = PsiUtil.isLValue(this);
String[] accessorNames =
isLValue
? GroovyPropertyUtils.suggestSettersName(name)
: GroovyPropertyUtils.suggestGettersName(name);
List<GroovyResolveResult> accessorResults = new ArrayList<GroovyResolveResult>();
for (String accessorName : accessorNames) {
AccessorResolverProcessor accessorResolver =
new AccessorResolverProcessor(
accessorName,
name,
this,
!isLValue,
false,
PsiImplUtil.getQualifierType(this),
getTypeArguments());
resolveRunner.resolveImpl(accessorResolver);
final GroovyResolveResult[] candidates = accessorResolver.getCandidates();
// can be only one correct candidate or some incorrect
if (candidates.length == 1 && candidates[0].isStaticsOK() && candidates[0].isAccessible()) {
return candidates;
} else {
ContainerUtil.addAll(accessorResults, candidates);
}
}
final ArrayList<GroovyResolveResult> fieldList = ContainerUtil.newArrayList(fieldCandidates);
filterOutBindings(fieldList);
if (!fieldList.isEmpty()) {
return fieldList.toArray(new GroovyResolveResult[fieldList.size()]);
}
if (classCandidates == null && canBeClassOrPackage) {
ResolverProcessor classProcessor = new ClassResolverProcessor(name, this, kinds);
resolveRunner.resolveImpl(classProcessor);
classCandidates = classProcessor.getCandidates();
}
if (classCandidates != null && classCandidates.length > 0) return classCandidates;
if (!accessorResults.isEmpty()) return new GroovyResolveResult[] {accessorResults.get(0)};
return GroovyResolveResult.EMPTY_ARRAY;
}
@Override
@Nullable
public IElementType getDotTokenType() {
PsiElement dot = getDotToken();
return dot == null ? null : dot.getNode().getElementType();
}
