/**
* resolves n to node of type R, via declaration if n is an identifier, via simple cast otherwise
* returns null if n's declaration or n can't be cast to R or S
*/
public Pair<R, S> resolve(BaseNode n, BaseNode parent) {
if (n instanceof IdentNode) {
Pair<R, S> pair = resolve((IdentNode) n);
if (pair != null) {
assert pair.fst == null || pair.snd == null;
parent.becomeParent(pair.fst);
parent.becomeParent(pair.snd);
}
return pair;
}
Pair<R, S> pair = new Pair<R, S>();
if (clsR.isInstance(n)) {
pair.fst = clsR.cast(n);
}
if (clsS.isInstance(n)) {
pair.snd = clsS.cast(n);
}
if (pair.fst != null || pair.snd != null) {
assert pair.fst == null || pair.snd == null;
return pair;
}
n.reportError(
"\""
+ n
+ "\" is a "
+ n.getUseString()
+ " but a "
+ Util.getStrListWithOr(classes, BaseNode.class, "getUseStr")
+ " is expected");
return null;
}
/**
* Make a new cast node with a target type and an expression, which is immediately marked as
* resolved Only to be called by type adjusting, after tree was already resolved
*
* @param coords The source code coordinates.
* @param targetType The target type.
* @param expr The expression to be casted.
* @param resolveResult Resolution result (should be true)
*/
public CastNode(Coords coords, TypeNode targetType, ExprNode expr, BaseNode parent) {
this(coords, targetType, expr);
parent.becomeParent(this);
resolve();
check();
}
/** @see de.unika.ipd.grgen.ast.BaseNode#resolveLocal() */
@Override
protected boolean resolveLocal() {
boolean successfullyResolved = true;
if (typeUnresolved instanceof PackageIdentNode)
Resolver.resolveOwner((PackageIdentNode) typeUnresolved);
else fixupDefinition(typeUnresolved, typeUnresolved.getScope());
type = typeResolver.resolve(typeUnresolved, this);
successfullyResolved = type != null && successfullyResolved;
return successfullyResolved;
}