@Override
public PsiType fun(GrMethodBaseImpl method) {
PsiType nominal = method.getNominalType();
if (nominal != null) {
if (!(nominal instanceof PsiClassType
&& hasTypeParametersToInfer((PsiClassType) nominal))) {
return nominal;
}
}
if (!GppTypeConverter.hasTypedContext(method)) {
LOG.assertTrue(method.isValid(), "invalid method");
final GrOpenBlock block = method.getBlock();
if (block != null) {
LOG.assertTrue(block.isValid(), "invalid code block");
PsiType inferred =
GroovyPsiManager.inferType(method, new MethodTypeInferencer(block));
if (inferred != null) {
if (nominal == null || nominal.isAssignableFrom(inferred)) {
return inferred;
}
}
}
}
if (nominal != null) {
return nominal;
}
return TypesUtil.getJavaLangObject(method);
}
private void checkExpression(@NotNull PsiExpression expression) {
if (expression.getParent() instanceof PsiParenthesizedExpression) {
return;
}
final PsiType expressionType = expression.getType();
if (expressionType == null
|| expressionType.equals(PsiType.VOID)
|| !TypeConversionUtil.isPrimitiveAndNotNull(expressionType)) {
return;
}
final PsiPrimitiveType primitiveType = (PsiPrimitiveType) expressionType;
final PsiClassType boxedType = primitiveType.getBoxedType(expression);
if (boxedType == null) {
return;
}
final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, false);
if (expectedType == null || ClassUtils.isPrimitive(expectedType)) {
return;
}
if (!expectedType.isAssignableFrom(boxedType)) {
// JLS 5.2 Assignment Conversion
// check if a narrowing primitive conversion is applicable
if (!(expectedType instanceof PsiClassType) || !PsiUtil.isConstantExpression(expression)) {
return;
}
final PsiClassType classType = (PsiClassType) expectedType;
final String className = classType.getCanonicalText();
if (!convertableBoxedClassNames.contains(className)) {
return;
}
if (!PsiType.BYTE.equals(expressionType)
&& !PsiType.CHAR.equals(expressionType)
&& !PsiType.SHORT.equals(expressionType)
&& !PsiType.INT.equals(expressionType)) {
return;
}
}
if (ignoreAddedToCollection && isAddedToCollection(expression)) {
return;
}
registerError(expression);
}
@Override
public void visitTypeCastExpression(@NotNull PsiTypeCastExpression expression) {
super.visitTypeCastExpression(expression);
final PsiExpression operand = expression.getOperand();
if (operand == null) {
return;
}
final PsiType operandType = operand.getType();
if (operandType == null) {
return;
}
final PsiType type = expression.getType();
if (type == null) {
return;
}
final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, true);
if (expectedType == null) {
return;
}
if (expectedType.equals(type)) {
return;
}
final PsiClass resolved = PsiUtil.resolveClassInType(expectedType);
if (resolved != null && !resolved.isPhysical()) {
return;
}
if (expectedType.isAssignableFrom(operandType)) {
// then it's redundant, and caught by the built-in exception
return;
}
if (isTypeParameter(expectedType)) {
return;
}
if (expectedType instanceof PsiArrayType) {
final PsiArrayType arrayType = (PsiArrayType) expectedType;
final PsiType componentType = arrayType.getDeepComponentType();
if (isTypeParameter(componentType)) {
return;
}
}
if (type instanceof PsiPrimitiveType || expectedType instanceof PsiPrimitiveType) {
return;
}
if (PsiPrimitiveType.getUnboxedType(type) != null
|| PsiPrimitiveType.getUnboxedType(expectedType) != null) {
return;
}
if (expectedType instanceof PsiClassType) {
final PsiClassType expectedClassType = (PsiClassType) expectedType;
final PsiClassType expectedRawType = expectedClassType.rawType();
if (type.equals(expectedRawType)) {
return;
}
if (type instanceof PsiClassType) {
final PsiClassType classType = (PsiClassType) type;
final PsiClassType rawType = classType.rawType();
if (rawType.equals(expectedRawType)) {
return;
}
}
if (type instanceof PsiArrayType) {
return;
}
}
if (ignoreInMatchingInstanceof && InstanceOfUtils.hasAgreeingInstanceof(expression)) {
return;
}
final PsiTypeElement castTypeElement = expression.getCastType();
if (castTypeElement == null) {
return;
}
registerError(castTypeElement, expectedType);
}
private static String[] getFieldNames(final RadComponent component, final String currentName) {
final ArrayList<String> result = new ArrayList<String>();
if (currentName != null) {
result.add(currentName);
}
final IRootContainer root = FormEditingUtil.getRoot(component);
final String className = root.getClassToBind();
if (className == null) {
return ArrayUtil.toStringArray(result);
}
final PsiClass aClass = FormEditingUtil.findClassToBind(component.getModule(), className);
if (aClass == null) {
return ArrayUtil.toStringArray(result);
}
final PsiField[] fields = aClass.getFields();
for (final PsiField field : fields) {
if (field.hasModifierProperty(PsiModifier.STATIC)) {
continue;
}
final String fieldName = field.getName();
if (Comparing.equal(currentName, fieldName)) {
continue;
}
if (!FormEditingUtil.isBindingUnique(component, fieldName, root)) {
continue;
}
final String componentClassName;
if (component instanceof RadErrorComponent) {
componentClassName = component.getComponentClassName();
} else if (component instanceof RadHSpacer || component instanceof RadVSpacer) {
componentClassName = Spacer.class.getName();
} else {
componentClassName = component.getComponentClass().getName();
}
final PsiType componentType;
try {
componentType =
JavaPsiFacade.getInstance(component.getProject())
.getElementFactory()
.createTypeFromText(componentClassName, null);
} catch (IncorrectOperationException e) {
continue;
}
final PsiType fieldType = field.getType();
if (!fieldType.isAssignableFrom(componentType)) {
continue;
}
result.add(fieldName);
}
String text = FormInspectionUtil.getText(component.getModule(), component);
if (text != null) {
String binding = BindingProperty.suggestBindingFromText(component, text);
if (binding != null && !result.contains(binding)) {
result.add(binding);
}
}
final String[] names = ArrayUtil.toStringArray(result);
Arrays.sort(names);
return names;
}
