/*******************************************************************************
* 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.common.internal.types;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jdt.core.Signature;
/**
* Static utility class used to compare two CompositeTypes for compatability
*
* @author cbateman
*
*/
public final class TypeComparator {
private static class SignatureTestResult {
/**
* the diagnostic
*/
private final Diagnostic diagnostic;
/**
* Measure of the probability that the tested signatures were meant to
* match. Larger value means higher probability.
*/
private final int matchQuality;
/**
* @param diagnostic
* @param matchQuality -
* Measure of the probability that the tested signatures were
* meant to match. Larger value means higher probability.
*/
public SignatureTestResult(final Diagnostic diagnostic,
final int matchQuality) {
super();
this.diagnostic = diagnostic;
this.matchQuality = matchQuality;
}
}
private final TypeComparatorDiagnosticFactory _factory;
/**
* Default Constructor
* @param factory
*/
public TypeComparator(final TypeComparatorDiagnosticFactory factory)
{
_factory = factory;
}
/**
* @param firstType
* @param secondType
* @return true if firstType is assignable to secondType or vice-versa,
* depending on their assignment and runtime types
*/
public Diagnostic calculateTypeCompatibility(
final CompositeType firstType, final CompositeType secondType) {
// first, box all primitives
final CompositeType boxedFirstType = TypeTransformer
.transformBoxPrimitives(firstType);
final CompositeType boxedSecondType = TypeTransformer
.transformBoxPrimitives(secondType);
final String[] mustBeSatisfied = boxedFirstType.getSignatures();
final String[] testSignatures = boxedSecondType.getSignatures();
List<String> mustbeMethods = Collections.emptyList();
List<String> mustbeTypes = Collections.emptyList();
for (final String mustbeSignature : mustBeSatisfied) {
if (TypeUtil.isMethodSignature(mustbeSignature)) {
if (mustbeMethods.isEmpty()) {
mustbeMethods = new ArrayList<String>(mustbeSignature
.length());
}
mustbeMethods.add(mustbeSignature);
} else {
if (mustbeTypes.isEmpty()) {
mustbeTypes = new ArrayList<String>(mustbeSignature
.length());
}
mustbeTypes.add(mustbeSignature);
}
}
final boolean mustbeWriteable = firstType.isLHS();
SignatureTestResult bestResult = null;
for (final String isSignature : testSignatures) {
SignatureTestResult testResult;
if (TypeUtil.isMethodSignature(isSignature)) {
testResult = checkMethodSignature(isSignature, mustbeTypes,
mustbeMethods);
if (testResult.diagnostic.getSeverity() == Diagnostic.OK) {
return testResult.diagnostic;
}
} else {
testResult = checkTypeSignature(isSignature, mustbeTypes,
mustbeMethods, mustbeWriteable);
if (testResult.diagnostic.getSeverity() == Diagnostic.OK) {
return checkAssignability(firstType, secondType);
}
}
if (bestResult == null
|| bestResult.matchQuality < testResult.matchQuality) {
bestResult = testResult;
}
}
// TODO: bestResult empty? (should not happen, but who knows...
return bestResult.diagnostic;
}
private SignatureTestResult checkTypeSignature(
final String isSignature, final List<String> mustbeTypes,
final List<String> mustbeMethods, final boolean mustbeWriteable) {
if (mustbeTypes.isEmpty()) {
final Diagnostic diag = _factory.create_METHOD_EXPRESSION_EXPECTED();
return new SignatureTestResult(diag, 0);
}
for (final String mustbeSignature : mustbeTypes) {
if (mustbeSignature.equals(isSignature)
|| canCoerce(isSignature, mustbeSignature, mustbeWriteable)) {
final Diagnostic diag = Diagnostic.OK_INSTANCE;
return new SignatureTestResult(diag, 5);
}
}
final String[] params = new String[2];
params[0] = readableSignatures(mustbeTypes);
params[1] = Signature.toString(isSignature);
final Diagnostic diag = _factory.create_INCOMPATIBLE_TYPES(params);
return new SignatureTestResult(diag, 1);
}
private SignatureTestResult checkMethodSignature(
final String isSignature, final List<String> mustbeTypes,
final List<String> mustbeMethods) {
if (mustbeMethods.isEmpty()) {
final Diagnostic diag = _factory.create_VALUE_EXPRESSION_EXPECTED();
return new SignatureTestResult(diag, 0);
}
for (final String mustbeSignature : mustbeMethods) {
if (methodSignaturesMatch(mustbeSignature, isSignature)) {
final Diagnostic diag = Diagnostic.OK_INSTANCE;
return new SignatureTestResult(diag, 5);
}
}
final String[] params = new String[2];
params[0] = readableSignatures(mustbeMethods);
params[1] = Signature
.toString(isSignature, "method", null, false, true); //$NON-NLS-1$
final Diagnostic diag = _factory.create_INCOMPATIBLE_METHOD_TYPES(params);
return new SignatureTestResult(diag, 1);
}
private static String readableSignatures(final List<String> signatures) {
StringBuilder res = null;
for (final String sig : signatures) {
String sigText;
if (TypeUtil.isMethodSignature(sig)) {
sigText = Signature.toString(sig, "method", null, false, true); //$NON-NLS-1$
} else {
sigText = Signature.toString(sig);
}
if (res == null) {
res = new StringBuilder(sigText);
} else {
res.append(", ").append(sigText); //$NON-NLS-1$
}
}
return res != null ? res.toString() : "[no signature]"; //$NON-NLS-1$
}
private static boolean canCoerce(final String testType,
final String checkType, final boolean checkTypeIsWritable) {
boolean canCoerce = canCoerce(testType, checkType);
// if the check type is writable, we need to be sure that the
// coercion can work in both directions
if (canCoerce && checkTypeIsWritable) {
// reverse roles: can checkType assign back to test type?
canCoerce &= canCoerce(checkType, testType);
}
return canCoerce;
}
private static boolean canCoerce(final String testType,
final String checkType) {
// can always to coerce to string or object
if (TypeCoercer.typeIsString(checkType)/*
|| TypeConstants.TYPE_JAVAOBJECT.equals(checkType)*/)
{
return true;
} else if (TypeCoercer.typeIsNumeric(checkType)) {
return canCoerceNumeric(testType);
} else if (TypeCoercer.typeIsBoolean(checkType)) {
return TypeCoercer.canCoerceToBoolean(testType);
}
// otherwise, no type coercion available
return false;
}
private static boolean canCoerceNumeric(final String testType) {
try {
TypeCoercer.coerceToNumber(testType);
// TODO: there is a case when coerceToNumber returns
// null meaning "not sure", that we may want to handle
// differently, with a warning
return true;
} catch (final TypeCoercionException tce) {
// outright failure -- can't coerce
return false;
}
}
private static boolean methodSignaturesMatch(final String firstMethodSig,
final String secondMethodSig) {
// TODO: need to account for primitive type coercions
if (firstMethodSig.equals(secondMethodSig)) {
return true;
}
final String[] firstMethodParams = Signature
.getParameterTypes(firstMethodSig);
final String[] secondMethodParams = Signature
.getParameterTypes(secondMethodSig);
// fail fast if param count doesn't match
if (firstMethodParams.length != secondMethodParams.length) {
return false;
}
// now check each parameter
for (int i = 0; i < firstMethodParams.length; i++) {
// need to box primitives before comparing
final String firstMethodParam = TypeTransformer
.transformBoxPrimitives(firstMethodParams[i]);
final String secondMethodParam = TypeTransformer
.transformBoxPrimitives(secondMethodParams[i]);
if (!firstMethodParam.equals(secondMethodParam)) {
return false;
}
}
// if we get to here then we need only check the return type
final String firstReturn = TypeTransformer
.transformBoxPrimitives(Signature.getReturnType(firstMethodSig));
final String secondReturn = TypeTransformer
.transformBoxPrimitives(Signature
.getReturnType(secondMethodSig));
if (!firstReturn.equals(secondReturn)) {
return false;
}
// if we get to here, then everything checks out
return true;
}
/**
* Precond: both firstType and secondType must represent value bindings.
*
* @param firstType
* @param secondType
* @return a diagnostic validating that the two composite have compatible
* assignability
*/
private Diagnostic checkAssignability(final CompositeType firstType,
final CompositeType secondType) {
if (firstType.isRHS() && !secondType.isRHS()) {
return _factory.create_PROPERTY_NOT_READABLE();
}
if (firstType.isLHS() && !secondType.isLHS()) {
return _factory.create_PROPERTY_NOT_WRITABLE();
}
return Diagnostic.OK_INSTANCE;
}
}