@Nullable
private static PsiType getTypeFromMapAccess(@NotNull GrReferenceExpressionImpl ref) {
// map access
GrExpression qualifier = ref.getQualifierExpression();
if (qualifier != null) {
PsiType qType = qualifier.getNominalType();
if (qType instanceof PsiClassType) {
PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics();
PsiClass clazz = qResult.getElement();
if (clazz != null) {
PsiClass mapClass =
JavaPsiFacade.getInstance(ref.getProject())
.findClass(CommonClassNames.JAVA_UTIL_MAP, ref.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;
}
public void visitAssignmentExpression(GrAssignmentExpression expression) {
GrExpression rValue = expression.getRValue();
GrExpression lValue = expression.getLValue();
if (myExpression.equals(rValue)) {
PsiType lType = lValue.getNominalType();
if (lType != null) {
myResult = new TypeConstraint[] {SubtypeConstraint.create(lType)};
} else if (lValue instanceof GrReferenceExpression) {
GroovyResolveResult result = ((GrReferenceExpression) lValue).advancedResolve();
PsiElement resolved = result.getElement();
if (resolved instanceof GrVariable) {
PsiType type = ((GrVariable) resolved).getTypeGroovy();
if (type != null) {
myResult =
new TypeConstraint[] {
SubtypeConstraint.create(result.getSubstitutor().substitute(type))
};
}
}
}
} else if (myExpression.equals(lValue)) {
if (rValue != null) {
PsiType rType = rValue.getType();
if (rType != null) {
myResult = new TypeConstraint[] {SupertypeConstraint.create(rType)};
}
}
}
}
private static void writeReturn(
StringBuilder builder, ExpressionContext context, final GrExpression expression) {
builder.append("return ");
final PsiType expectedReturnType = PsiImplUtil.inferReturnType(expression);
final PsiType nnReturnType =
expectedReturnType == null || expectedReturnType == PsiType.VOID
? TypesUtil.getJavaLangObject(expression)
: expectedReturnType;
wrapInCastIfNeeded(
builder,
nnReturnType,
expression.getNominalType(),
expression,
context,
new StatementWriter() {
@Override
public void writeStatement(StringBuilder builder, ExpressionContext context) {
writeExpression(expression, builder, context);
}
});
builder.append(';');
}
@Nullable
public static PsiType inferExpectedTypeForDiamond(GrExpression diamondNew) {
PsiElement skipped = PsiUtil.skipParentheses(diamondNew, true);
assert skipped != null;
PsiElement pparent = skipped.getParent();
if (pparent instanceof GrAssignmentExpression
&& PsiTreeUtil.isAncestor(
((GrAssignmentExpression) pparent).getRValue(), diamondNew, false)) {
GrExpression lValue = ((GrAssignmentExpression) pparent).getLValue();
if (PsiUtil.mightBeLValue(lValue)) {
return lValue.getNominalType();
}
} else if (pparent instanceof GrVariable
&& ((GrVariable) pparent).getInitializerGroovy() == diamondNew) {
return ((GrVariable) pparent).getDeclaredType();
} else if (pparent instanceof GrListOrMap) {
PsiElement ppparent = PsiUtil.skipParentheses(pparent.getParent(), true);
if (ppparent instanceof GrAssignmentExpression
&& PsiTreeUtil.isAncestor(
((GrAssignmentExpression) ppparent).getRValue(), pparent, false)) {
PsiElement lValue =
PsiUtil.skipParentheses(((GrAssignmentExpression) ppparent).getLValue(), false);
if (lValue instanceof GrTupleExpression) {
GrExpression[] initializers = ((GrListOrMap) pparent).getInitializers();
int index = ArrayUtil.find(initializers, diamondNew);
GrExpression[] expressions = ((GrTupleExpression) lValue).getExpressions();
if (index < expressions.length) {
return expressions[index].getNominalType();
}
}
}
}
return null;
}