| /******************************************************************************* |
| * Copyright (c) 2006 Oracle Corporation. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Cameron Bateman/Oracle - initial API and implementation |
| * |
| ********************************************************************************/ |
| |
| package org.eclipse.jst.jsf.validation.internal.el.operators; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jst.jsf.common.internal.types.BooleanLiteralType; |
| import org.eclipse.jst.jsf.common.internal.types.IAssignable; |
| import org.eclipse.jst.jsf.common.internal.types.LiteralType; |
| import org.eclipse.jst.jsf.common.internal.types.StringLiteralType; |
| import org.eclipse.jst.jsf.common.internal.types.TypeCoercer; |
| import org.eclipse.jst.jsf.common.internal.types.TypeCoercionException; |
| import org.eclipse.jst.jsf.common.internal.types.TypeConstants; |
| import org.eclipse.jst.jsf.common.internal.types.TypeTransformer; |
| import org.eclipse.jst.jsf.common.internal.types.ValueType; |
| import org.eclipse.jst.jsf.common.util.TypeUtil; |
| import org.eclipse.jst.jsf.context.symbol.internal.util.IObjectSymbolBasedValueType; |
| import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory; |
| |
| /** |
| * A relational binary operator for equality: "==" or "!=" |
| * |
| * @author cbateman |
| * |
| */ |
| /*package*/ abstract class EqualityRelationalBinaryOperator extends RelationalBinaryOperator |
| { |
| EqualityRelationalBinaryOperator(final DiagnosticFactory diagnosticFactory, String jsfVersion) |
| { |
| super(diagnosticFactory, jsfVersion); |
| } |
| |
| /** |
| * @param firstArg |
| * @param secondArg |
| * @return the result of the operation |
| */ |
| protected abstract boolean doRealOperation(Boolean firstArg, Boolean secondArg); |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jst.jsf.validation.internal.el.operators.BinaryOperator#performOperation(org.eclipse.jst.jsf.core.internal.types.ValueType, org.eclipse.jst.jsf.core.internal.types.ValueType) |
| */ |
| public ValueType performOperation(ValueType firstArg, ValueType secondArg) |
| { |
| // JSP.2.3.5.7 step 1 if operands are equal, then true for ==, false for != |
| if (TypeCoercer.typeIsNull(firstArg.getSignature()) |
| && TypeCoercer.typeIsNull(secondArg.getSignature())) |
| { |
| // perform the operation on two arguments that are equal. |
| return BooleanLiteralType.valueOf(doRealOperation(Integer.valueOf(4), Integer.valueOf(4))); |
| } |
| |
| String boxedFirstType = TypeTransformer.transformBoxPrimitives(firstArg.getSignature()); |
| String boxedSecondType = TypeTransformer.transformBoxPrimitives(secondArg.getSignature()); |
| |
| // JSP.2.3.5.7 step 3, if either is BigDecimal, promote both and compare |
| if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstType) |
| || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondType)) |
| { |
| return handleNumericComparison(firstArg, secondArg, BigDecimal.class); |
| } |
| |
| // JSP.2.3.5.7, step 4 if either is a float or double, promote both to |
| // double and compare |
| if (TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondType)) |
| { |
| return handleNumericComparison(firstArg, secondArg, Double.class); |
| } |
| |
| // JSP.2.3.5.7, step 5 if either is a big integer, promote and compare |
| if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstType) |
| || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondType)) |
| { |
| return handleNumericComparison(firstArg, secondArg, BigInteger.class); |
| } |
| |
| // JSP.2.3.5.7, step 6 if either is Long or smaller, coerce both to Long |
| if (TypeConstants.TYPE_BOXED_LONG.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_LONG.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_INTEGER.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_INTEGER.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_SHORT.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_SHORT.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_BYTE.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_BYTE.equals(boxedSecondType) |
| || TypeConstants.SIGNATURE_BOXED_CHARACTER.equals(boxedFirstType) |
| || TypeConstants.SIGNATURE_BOXED_CHARACTER.equals(boxedSecondType)) |
| { |
| return handleNumericComparison(firstArg, secondArg, Long.class); |
| } |
| |
| // JSP.2.3.5.7, step 7 if either is a boolean, coerce to boolean |
| if (TypeConstants.TYPE_BOXED_BOOLEAN.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_BOOLEAN.equals(boxedSecondType)) |
| { |
| return handleBooleanComparison(firstArg, secondArg); |
| } |
| |
| // Unified EL 1.8.2, step 8 if either is a enum, then coerce both to enum |
| // NOTE: we handle the JSF 1.1 case also where enums are treated as non-coercable |
| // Object's |
| if (firstArg.isEnumType() || secondArg.isEnumType()) |
| { |
| return handleEnumComparison(firstArg, secondArg); |
| } |
| |
| // JSP.2.3.5.7, step 8 if either is a string, coerce to string and |
| // compare lexically |
| if (TypeConstants.TYPE_STRING.equals(boxedFirstType) |
| || TypeConstants.TYPE_STRING.equals(boxedSecondType)) |
| { |
| return handleStringComparison(firstArg, secondArg); |
| } |
| |
| // otherwise, an equal compare will be done A.equals(B). Since |
| return new ValueType(TypeConstants.TYPE_BOOLEAN, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| |
| private ValueType handleEnumComparison(ValueType firstArg, |
| ValueType secondArg) |
| { |
| assert firstArg.isEnumType() || secondArg.isEnumType(); |
| |
| // if the first is not an enum, then we have non-Enum == Enum case |
| if (!firstArg.isEnumType()) |
| { |
| return handleComparsionOfEnumAndNonEnum(secondArg, firstArg); |
| } |
| |
| // if the second is not an enum, then we have Enum == non-Enum case |
| if (!secondArg.isEnumType()) |
| { |
| return handleComparsionOfEnumAndNonEnum(firstArg, secondArg); |
| } |
| |
| // only other case is they are both enums. Check if they are directly |
| // comparable. |
| if (TypeUtil.canNeverBeEqual(firstArg.getSignature(), secondArg.getSignature())) |
| { |
| boolean result = doRealOperation("foo", "notFoo"); // just simulate the operation where the operands are not equal //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| return BooleanLiteralType.valueOf(result); |
| } |
| |
| // otherwise, all we know is that it's a boolean |
| return new ValueType(TypeConstants.TYPE_BOOLEAN, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| |
| private ValueType handleComparsionOfEnumAndNonEnum(ValueType enumType, |
| ValueType nonEnumType) |
| { |
| // the only literal value that could have got us here is a |
| // StringLiteralValue since the others a filtered out before this is |
| // called |
| if (nonEnumType instanceof LiteralType) |
| { |
| assert nonEnumType instanceof StringLiteralType; |
| |
| Diagnostic result = validateIfEnumToStringComparison(((StringLiteralType)nonEnumType).getLiteralValue(), enumType); |
| |
| if (result != null) |
| { |
| // compare two things that aren't equal |
| return BooleanLiteralType.valueOf(doRealOperation("foo", "foo_")); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| return new ValueType(TypeConstants.TYPE_BOOLEAN, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| |
| // if the arg is a String, then we can't prove anything before runtime |
| if (nonEnumType.isInstanceOf(TypeConstants.TYPE_STRING)) |
| { |
| return new ValueType(TypeConstants.TYPE_BOOLEAN, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| // otherwise, we know it will result in a problem since one is an enum |
| // and the other isn't so simply do a comparison on two things that aren't equals |
| return BooleanLiteralType.valueOf(doRealOperation("foo", "foo_")); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| public Diagnostic validate(ValueType firstArg, ValueType secondArg) { |
| if (TypeConstants.TYPE_JAVAOBJECT.equals(firstArg.getSignature()) || |
| TypeConstants.TYPE_JAVAOBJECT.equals(secondArg.getSignature())) { |
| return Diagnostic.OK_INSTANCE; |
| } |
| |
| // JSP.2.3.5.7 step 2 if either operand is null, then not equal |
| if (TypeCoercer.typeIsNull(firstArg.getSignature()) |
| && TypeCoercer.typeIsNull(secondArg.getSignature())) |
| { |
| // perform the operation on two arguments that are equal. |
| final boolean result = doRealOperation(Integer.valueOf(4), Integer.valueOf(4)); |
| return _diagnosticFactory.create_BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME(Boolean.toString(result)); |
| } |
| |
| final String boxedFirstType = |
| TypeTransformer.transformBoxPrimitives(firstArg.getSignature()); |
| final String boxedSecondType = |
| TypeTransformer.transformBoxPrimitives(secondArg.getSignature()); |
| |
| // JSP.2.3.5.7 step 3, if either is BigDecimal, promote both and compare |
| if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstType) |
| || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondType)) |
| { |
| return validateNumericComparison(firstArg, secondArg, BigDecimal.class); |
| } |
| |
| // JSP.2.3.5.7, step 4 if either is a float or double, promote both to |
| // double and compare |
| if (TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondType)) |
| { |
| return validateNumericComparison(firstArg, secondArg, Double.class); |
| } |
| |
| // JSP.2.3.5.7, step 5 if either is a big integer, promote and compare |
| if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstType) |
| || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondType)) |
| { |
| return validateNumericComparison(firstArg, secondArg, BigInteger.class); |
| } |
| |
| // JSP.2.3.5.7, step 6 if either is Long or smaller, coerce both to Long |
| if (TypeConstants.TYPE_BOXED_LONG.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_LONG.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_INTEGER.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_INTEGER.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_SHORT.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_SHORT.equals(boxedSecondType) |
| || TypeConstants.TYPE_BOXED_BYTE.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_BYTE.equals(boxedSecondType) |
| || TypeConstants.SIGNATURE_BOXED_CHARACTER.equals(boxedFirstType) |
| || TypeConstants.SIGNATURE_BOXED_CHARACTER.equals(boxedSecondType)) |
| { |
| return validateNumericComparison(firstArg, secondArg, Long.class); |
| } |
| |
| // JSP.2.3.5.7, step 7 if either is a boolean, coerce to boolean |
| if (TypeConstants.TYPE_BOXED_BOOLEAN.equals(boxedFirstType) |
| || TypeConstants.TYPE_BOXED_BOOLEAN.equals(boxedSecondType)) |
| { |
| return validateBooleanComparison(firstArg, secondArg); |
| } |
| |
| // Unified EL 1.8.2, step 8 if either is a enum, then coerce both to enum |
| // NOTE: we handle the JSF 1.1 case also where enums are treated as non-coercable |
| // Object's |
| if (firstArg.isEnumType() || secondArg.isEnumType()) |
| { |
| return validateEnumComparison(firstArg, secondArg); |
| } |
| |
| // JSP.2.3.5.7, step 8 if either is a string, coerce to string and |
| // compare lexically |
| if (TypeConstants.TYPE_STRING.equals(boxedFirstType) |
| || TypeConstants.TYPE_STRING.equals(boxedSecondType)) |
| { |
| return validateStringComparison(firstArg, secondArg); |
| } |
| |
| // otherwise, an equal compare will be done A.equals(B). Since |
| return Diagnostic.OK_INSTANCE; |
| } |
| |
| |
| /** |
| * Both types are coerced to boolean before comparison |
| * |
| * @param firstArg |
| * @param secondArg |
| * @return the result of the comparison |
| */ |
| private ValueType handleBooleanComparison(ValueType firstArg, ValueType secondArg) |
| { |
| boolean canCoerceFirstArg = |
| TypeCoercer.canCoerceToBoolean(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| boolean canCoerceSecondArg = TypeCoercer.canCoerceToBoolean(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| if (! (canCoerceFirstArg && canCoerceSecondArg)) |
| { |
| return null; |
| } |
| |
| if (firstArg instanceof LiteralType && secondArg instanceof LiteralType) |
| { |
| try |
| { |
| Boolean firstValue = ((LiteralType)firstArg).coerceToBoolean(); |
| Boolean secondValue = ((LiteralType)secondArg).coerceToBoolean(); |
| |
| if (firstValue != null && secondValue != null) |
| { |
| boolean result = doRealOperation(firstValue, secondValue); |
| return result ? |
| BooleanLiteralType.TRUE : |
| BooleanLiteralType.FALSE; |
| } |
| } |
| catch (TypeCoercionException tce) |
| { |
| throw new AssertionError("should never get here; have already checked coercability above"); //$NON-NLS-1$ |
| } |
| } |
| |
| // otherwise, we have a valid comparison that results in boolean |
| return new ValueType(TypeConstants.TYPE_BOOLEAN, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| |
| private Diagnostic validateBooleanComparison(ValueType firstType, ValueType secondType) |
| { |
| boolean canCoerceFirstArg = |
| TypeCoercer.canCoerceToBoolean(TypeTransformer.transformBoxPrimitives(firstType.getSignature())); |
| boolean canCoerceSecondArg = TypeCoercer.canCoerceToBoolean(TypeTransformer.transformBoxPrimitives(secondType.getSignature())); |
| |
| if (!canCoerceFirstArg) |
| { |
| return _diagnosticFactory.create_BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN(Messages.getString("EqualityRelationalBinaryOperator.FirstArgument")); //$NON-NLS-1$ |
| } |
| |
| if (!canCoerceSecondArg) |
| { |
| return _diagnosticFactory.create_BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN(Messages.getString("EqualityRelationalBinaryOperator.SecondArgument")); //$NON-NLS-1$ |
| } |
| |
| if (firstType instanceof LiteralType && secondType instanceof LiteralType) |
| { |
| try |
| { |
| Boolean firstValue = ((LiteralType)firstType).coerceToBoolean(); |
| Boolean secondValue = ((LiteralType)secondType).coerceToBoolean(); |
| |
| if (firstValue != null && secondValue != null) |
| { |
| final boolean result = |
| doRealOperation(firstValue, secondValue); |
| return _diagnosticFactory. |
| create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME(getOperationName(), Boolean.toString(result)); |
| } |
| } |
| catch (TypeCoercionException tce) |
| { |
| throw new AssertionError("should never get here; have already checked coercability above"); //$NON-NLS-1$ |
| } |
| } |
| |
| // otherwise, we have a valid comparison |
| return Diagnostic.OK_INSTANCE; |
| } |
| |
| @Override |
| protected Diagnostic validateStringComparison(ValueType firstType, |
| ValueType secondType) |
| { |
| String firstValue = null; |
| |
| if (firstType instanceof LiteralType) |
| { |
| firstValue = ((LiteralType)firstType).getLiteralValue(); |
| } |
| |
| String secondValue = null; |
| if (secondType instanceof LiteralType) |
| { |
| secondValue = ((LiteralType)secondType).getLiteralValue(); |
| } |
| |
| if (firstValue != null) |
| { |
| Diagnostic result = validateIfEnumToStringComparison(firstValue, secondType); |
| |
| if (result != null) |
| { |
| return result; |
| } |
| } |
| |
| if (secondValue != null) |
| { |
| Diagnostic result = validateIfEnumToStringComparison(secondValue, firstType); |
| |
| if (result != null) |
| { |
| return result; |
| } |
| } |
| |
| // if it's a string to enum compare, do the default parent thing |
| return super.validateStringComparison(firstType, secondType); |
| } |
| |
| |
| @Override |
| protected ValueType handleStringComparison(ValueType firstType, |
| ValueType secondType) |
| { |
| String firstValue = null; |
| |
| if (firstType instanceof LiteralType) |
| { |
| firstValue = ((LiteralType)firstType).getLiteralValue(); |
| } |
| |
| String secondValue = null; |
| if (secondType instanceof LiteralType) |
| { |
| secondValue = ((LiteralType)secondType).getLiteralValue(); |
| } |
| |
| if (firstValue != null) |
| { |
| Diagnostic result = validateIfEnumToStringComparison(firstValue, secondType); |
| |
| if (result != null) |
| { |
| return handleIfEnumToNonMemberStringComparison(firstValue, secondType); |
| } |
| } |
| |
| if (secondValue != null) |
| { |
| Diagnostic result = validateIfEnumToStringComparison(secondValue, firstType); |
| |
| if (result != null) |
| { |
| return handleIfEnumToNonMemberStringComparison(secondValue, firstType); |
| } |
| } |
| |
| // otherwise, do the super thing |
| return super.handleStringComparison(firstType, secondType); |
| } |
| |
| private Diagnostic validateEnumComparison(final ValueType firstArg, final ValueType secondArg) |
| { |
| assert firstArg.isEnumType() || secondArg.isEnumType(); |
| |
| // if the first is not an enum, then we have non-Enum == Enum case |
| if (!firstArg.isEnumType()) |
| { |
| return validateComparsionOfEnumAndNonEnum(firstArg, secondArg); |
| } |
| |
| // if the second is not an enum, then we have Enum == non-Enum case |
| if (!secondArg.isEnumType()) |
| { |
| return validateComparsionOfEnumAndNonEnum(secondArg, firstArg); |
| } |
| |
| // only other case is they are both enums. Check if they are directly |
| // comparable. |
| if (TypeUtil.canNeverBeEqual(firstArg.getSignature(), secondArg.getSignature())) |
| { |
| return _diagnosticFactory. |
| create_BINARY_COMPARISON_WITH_TWO_ENUMS_ALWAYS_SAME |
| (getOperationName() |
| , doRealOperation("foo", "notFoo") // just simulate the operation where the operands are not equal //$NON-NLS-1$ //$NON-NLS-2$ |
| , TypeUtil.getFullyQualifiedName(firstArg.getSignature()) |
| , TypeUtil.getFullyQualifiedName(secondArg.getSignature())); |
| } |
| |
| // otherwise, it's all good |
| return Diagnostic.OK_INSTANCE; |
| } |
| |
| private Diagnostic validateComparsionOfEnumAndNonEnum(final ValueType nonEnumType, final ValueType enumType) |
| { |
| // the only literal value that could have got us here is a |
| // StringLiteralValue since the others a filtered out before this is |
| // called |
| if (nonEnumType instanceof LiteralType) |
| { |
| assert nonEnumType instanceof StringLiteralType; |
| |
| Diagnostic result = validateIfEnumToStringComparison(((StringLiteralType)nonEnumType).getLiteralValue(), enumType); |
| |
| if (result != null) |
| { |
| return result; |
| } |
| return Diagnostic.OK_INSTANCE; |
| } |
| |
| // if the arg is a String, then we can't prove anything before runtime |
| if (nonEnumType.isInstanceOf(TypeConstants.TYPE_STRING)) |
| { |
| return Diagnostic.OK_INSTANCE; |
| } |
| // otherwise, we know it will result in a problem since one is an enum |
| // and the other isn't |
| return _diagnosticFactory. |
| create_BINARY_COMPARISON_WITH_ENUM_AND_UNCOERCABLE_NONCONST_ALWAYS_SAME |
| (getOperationName() |
| , doRealOperation("foo", "notFoo") // just simulate the operation where the operands are not equal //$NON-NLS-1$ //$NON-NLS-2$ |
| , TypeUtil.getFullyQualifiedName(enumType.getSignature()) |
| , TypeUtil.getFullyQualifiedName(nonEnumType.getSignature())); |
| } |
| |
| private Diagnostic validateIfEnumToStringComparison(final String literalValue, final ValueType validateIfEnum) |
| { |
| if (validateIfEnum.isEnumType() |
| && validateIfEnum instanceof IObjectSymbolBasedValueType) |
| { |
| final IObjectSymbolBasedValueType symbolValueType = |
| (IObjectSymbolBasedValueType) validateIfEnum; |
| |
| IType type = symbolValueType.getSymbol().getTypeDescriptor().resolveType(symbolValueType.getSymbol().getTypeDescriptor().getTypeSignature()); |
| |
| if (type != null && !TypeUtil.isEnumMember(type, literalValue)) |
| { |
| return _diagnosticFactory. |
| create_BINARY_COMPARISON_WITH_ENUM_AND_CONST_ALWAYS_SAME |
| (getOperationName() |
| , doRealOperation(literalValue, literalValue+"_") // just simulate the operation where the operands are not equal //$NON-NLS-1$ |
| , TypeUtil.getFullyQualifiedName(validateIfEnum.getSignature()) |
| , literalValue); |
| } |
| } |
| |
| return null; |
| } |
| |
| private ValueType handleIfEnumToNonMemberStringComparison(final String literalValue, final ValueType enumValueType) |
| { |
| // we need to apply the real operation to literalValue and any string that !equals(literalValue) |
| // since it's not a member of the enum |
| return BooleanLiteralType.valueOf(doRealOperation(literalValue, literalValue+"_")); //$NON-NLS-1$ |
| } |
| } |
