/*******************************************************************************
* Copyright (c) 2001, 2008 Oracle Corporation and others.
* 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:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.validation.internal.el.operators;
import org.eclipse.core.resources.IFile;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jst.jsf.common.internal.types.LiteralType;
import org.eclipse.jst.jsf.common.internal.types.NullLiteralType;
import org.eclipse.jst.jsf.common.internal.types.SignatureBasedType;
import org.eclipse.jst.jsf.common.internal.types.TypeCoercer;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.internal.types.ValueType;
import org.eclipse.jst.jsf.context.symbol.IMethodSymbol;
import org.eclipse.jst.jsf.context.symbol.IObjectSymbol;
import org.eclipse.jst.jsf.context.symbol.IPropertySymbol;
import org.eclipse.jst.jsf.context.symbol.ISymbol;
import org.eclipse.jst.jsf.context.symbol.internal.util.IMethodSymbolBasedType;
import org.eclipse.jst.jsf.context.symbol.internal.util.IObjectSymbolBasedValueType;
import org.eclipse.jst.jsf.designtime.resolver.ISymbolContextResolver;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
/**
* Super-class for all operators whose function is to access members of an EL
* object. i.e. the "." and "[]" operators
*
* @author cbateman
*
*/
public abstract class MemberAccessorOperator
{
/**
* The source file for the EL expression in which this operator is being
* evaluated.
*/
protected final IFile _file;
/**
* the common factory used to create diagnostics
*/
protected final DiagnosticFactory _diagnosticFactory;
/**
* Used to resolve variables and properties.
*/
protected final ISymbolContextResolver _contextResolver;
// TODO: need to reconcile with BinaryOperator? performOperation must return
// SignatureBasedType since it may return a method. This can't happen
// with other operators (besides eqiv [])
/**
* @param file
* @param diagnosticFactory
* @param contextResolver
*/
protected MemberAccessorOperator(final IFile file,
final DiagnosticFactory diagnosticFactory, final ISymbolContextResolver contextResolver)
{
_file = file;
_diagnosticFactory = diagnosticFactory;
_contextResolver = contextResolver;
}
/**
* @param firstArg
* @param secondArg
* @return the result of validating the dot operation with these arguments.
*/
public Diagnostic validate(final ValueType firstArg, final ValueType secondArg)
{
if (TypeConstants.TYPE_JAVAOBJECT.equals(firstArg.getSignature())) {
return Diagnostic.OK_INSTANCE;
}
if (!(firstArg instanceof IObjectSymbolBasedValueType))
{
throw new AssertionError(
"The first argument of the member operator must always be a symbol resolvable value type"); //$NON-NLS-1$
}
if (TypeCoercer.typeIsNull(secondArg.getSignature()))
{
return _diagnosticFactory
.create_BINARY_OP_DOT_WITH_VALUEB_NULL(getOperatorName());
}
return validateObjectSymbolValue(
(IObjectSymbolBasedValueType) firstArg, secondArg);
}
/**
* @param firstArg
* @param secondArg
* @return the diagnostic for member(firstArg, secondArg)
*/
protected abstract Diagnostic validateObjectSymbolValue(
IObjectSymbolBasedValueType firstArg, ValueType secondArg);
/**
* @param firstArg
* @param secondArg
* @return a validation of a named property accessible base (map or bean)
* given an a literal key argument
*/
protected Diagnostic validateNamedPropertyAccessorBase(
final IObjectSymbolBasedValueType firstArg, final LiteralType secondArg)
{
final IObjectSymbol curBaseSymbol = firstArg.getSymbol();
final ISymbol nextSymbol =
getMemberSymbol(firstArg.getSymbol(), secondArg
.getLiteralValueRaw());
// if the x in x.y is an unconstrained map an it returns
// a java.lang.Object, then return null. We can't really say
// anything meaningful about such a property anyway.
// TODO: do we need to refine the type descriptor on such
// a property object to make this more precise?
if (curBaseSymbol.supportsCoercion(TypeConstants.TYPE_MAP)
&& nextSymbol instanceof IPropertySymbol
&& TypeConstants.TYPE_JAVAOBJECT
.equals(((IPropertySymbol) nextSymbol)
.getTypeDescriptor().getTypeSignature()))
{
// if we get a symbol back that's a generic object coming from a map
// then stop validating; we can't tell anything for sure
return Diagnostic.OK_INSTANCE;
}
if (nextSymbol == null)
{
return _diagnosticFactory.create_MEMBER_NOT_FOUND(secondArg
.getLiteralValue(), firstArg.getSymbol().getName());
}
return Diagnostic.OK_INSTANCE;
}
/**
* @param firstArg
* @param secondArg
* @return the resolved type for the operation or null if not computable
*/
public SignatureBasedType performOperation(final ValueType firstArg,
final ValueType secondArg)
{
if (!(firstArg instanceof IObjectSymbolBasedValueType))
{
return null;
}
// per JSP.2.3.4, if value-b is null, then return null (not literal
// null)
if (TypeCoercer.typeIsNull(secondArg.getSignature()))
{
return null;
}
return handlePerformObjectSymbolValue(
(IObjectSymbolBasedValueType) firstArg, secondArg);
}
/**
* @param firstArg --
* represents value-a (expr-a after step 1) in JSP.2.3.4
* @param secondArg --
* represents value-b (expr-b after step 3) in JSP.2.3.4
* @return the new ValueType for this operation or null
*/
protected abstract SignatureBasedType handlePerformObjectSymbolValue(
IObjectSymbolBasedValueType firstArg, ValueType secondArg);
/**
* @param firstArg
* @param secondArg
* @return the resolved type for firstArg[secondArg] treating firstArg as a
* type that uses a named property accessor (i.e. a map or bean but
* not a list or array) or null if unresolved
*/
protected SignatureBasedType handlePerformNamedPropertyAccessorBase(
final IObjectSymbolBasedValueType firstArg, final LiteralType secondArg)
{
final ISymbol symbol =
getMemberSymbol(firstArg.getSymbol(), secondArg
.getLiteralValueRaw());
if (symbol instanceof IPropertySymbol)
{
return new IObjectSymbolBasedValueType((IPropertySymbol) symbol);
}
else if (symbol instanceof IMethodSymbol)
{
return new IMethodSymbolBasedType((IMethodSymbol) symbol);
}
// fall-through and return null
// per JSP2.3.4 steps 5 and 6, return null literal if map, null (error)
// otherwise
if (firstArg.isInstanceOf(TypeConstants.TYPE_MAP))
{
return NullLiteralType.SINGLETON;
}
return null;
}
/**
* @param symbol
* @param name
* @return the member symbol of 'symbol' corresponding to 'name' or null if
* there is no such member
*/
protected final ISymbol getMemberSymbol(final IObjectSymbol symbol,
final Object name)
{
ISymbol memberSymbol = getPropertySymbol(symbol, name);
if (memberSymbol != null)
{
return memberSymbol;
}
memberSymbol = getMethodSymbol(symbol, name);
// otherwise, see if it's a valid method
if (memberSymbol != null)
{
return memberSymbol;
}
// if not a property or method, then not a valid member
return null;
}
/**
* @param symbol
* @param name
* @return the property symbol called name relative to 'symbol' or null if
* one doesn't exist
*/
protected final ISymbol getPropertySymbol(final ISymbol symbol,
final Object name)
{
return _contextResolver.getProperty(symbol, name);
}
/**
* @param symbol
* @param name
* @return the method symbol on 'symbol' corresponding to 'name' or null if
* no such member
*/
protected final IMethodSymbol getMethodSymbol(final IObjectSymbol symbol,
final Object name)
{
return _contextResolver.getMethod(symbol, name);
}
/**
* @return a user-readable name of the operator (i.e. dot or bracket)
*/
protected abstract String getOperatorName();
}