@Nullable
private static PsiType getInferredTypes(
GrReferenceExpressionImpl refExpr, @Nullable PsiElement resolved) {
final GrExpression qualifier = refExpr.getQualifier();
if (qualifier == null && !(resolved instanceof PsiClass)) {
return TypeInferenceHelper.getCurrentContext().getVariableType(refExpr);
} else if (qualifier != null) {
// map access
PsiType qType = qualifier.getType();
if (qType instanceof PsiClassType && !(qType instanceof GrMapType)) {
PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics();
PsiClass clazz = qResult.getElement();
if (clazz != null) {
PsiClass mapClass =
JavaPsiFacade.getInstance(refExpr.getProject())
.findClass(CommonClassNames.JAVA_UTIL_MAP, refExpr.getResolveScope());
if (mapClass != null && mapClass.getTypeParameters().length == 2) {
PsiSubstitutor substitutor =
TypeConversionUtil.getClassSubstitutor(mapClass, clazz, qResult.getSubstitutor());
if (substitutor != null) {
return TypeConversionUtil.erasure(
substitutor.substitute(mapClass.getTypeParameters()[1]));
}
}
}
}
}
return null;
}
@NotNull
private Set<String> addAllRestrictedProperties() {
if (myRefExpr.getQualifier() != null) {
return Collections.emptySet();
}
Set<String> propertyNames = new HashSet<String>();
for (GrTypeDefinition containingClass =
PsiTreeUtil.getParentOfType(myRefExpr, GrTypeDefinition.class);
containingClass != null;
containingClass = PsiTreeUtil.getParentOfType(containingClass, GrTypeDefinition.class)) {
for (PsiField field : containingClass.getFields()) {
propertyNames.add(field.getName());
}
}
return propertyNames;
}
@Nullable
public PsiType fun(GrReferenceExpressionImpl refExpr) {
PsiType result = GrReassignedLocalVarsChecker.checkReassignedVar(refExpr, true);
if (result != null) return result;
if (GrUnresolvedAccessInspection.isClassReference(refExpr)) {
GrExpression qualifier = refExpr.getQualifier();
LOG.assertTrue(qualifier != null);
return TypesUtil.createJavaLangClassType(
qualifier.getType(), refExpr.getProject(), refExpr.getResolveScope());
}
final PsiElement resolved = refExpr.resolve();
final PsiType inferred = getInferredTypes(refExpr, resolved);
final PsiType nominal = refExpr.getNominalType();
if (inferred == null || PsiType.NULL.equals(inferred)) {
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;
}