net.sf.saxon.expr.LetExpression Maven / Gradle / Ivy
package net.sf.saxon.expr;
import net.sf.saxon.evpull.EventIterator;
import net.sf.saxon.instruct.DocumentInstr;
import net.sf.saxon.instruct.GlobalVariable;
import net.sf.saxon.instruct.TailCall;
import net.sf.saxon.instruct.TailCallReturner;
import net.sf.saxon.om.Item;
import net.sf.saxon.om.SequenceIterator;
import net.sf.saxon.om.StructuredQName;
import net.sf.saxon.om.ValueRepresentation;
import net.sf.saxon.trace.ExpressionPresenter;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.type.ItemType;
import net.sf.saxon.type.SchemaType;
import net.sf.saxon.type.TypeHierarchy;
import net.sf.saxon.value.Cardinality;
import net.sf.saxon.value.SequenceType;
import java.util.List;
import java.util.ArrayList;
/**
* A LetExpression is modelled on the XQuery syntax let $x := expr return expr. This syntax
* is not available in the surface XPath language, but it is used internally in an optimized
* expression tree.
*/
public class LetExpression extends Assignation implements TailCallReturner {
// This integer holds an approximation to the number of times that the declared variable is referenced.
// The value 1 means there is only one reference and it is not in a loop, which means that the value will
// not be retained in memory. If there are multiple references or references within a loop, the value will
// be a small integer > 1. The special value FILTERED indicates that there is a reference within a loop
// in the form $x[predicate], which indicates that the value should potentially be indexable.
int refCount;
int evaluationMode = ExpressionTool.UNDECIDED;
/**
* Create a LetExpression
*/
public LetExpression() {
//System.err.println("let");
}
/**
* Indicate that the variable bound by this let expression should be indexable
* (because it is used in an appropriate filter expression)
*/
public void setIndexedVariable() {
refCount = FilterExpression.FILTERED;
}
/**
* Test whether the variable bound by this let expression should be indexable
* @return true if the variable should be indexable
*/
public boolean isIndexedVariable() {
return (refCount == FilterExpression.FILTERED);
}
/**
* Get the (nominal) count of the number of references to this variable
* @return zero if there are no references, one if there is a single reference that is not in
* a loop, some higher number if there are multiple references (or a single reference in a loop),
* or the special value @link RangeVariable#FILTERED} if there are any references
* in filter expressions that require searching.
*/
public int getNominalReferenceCount() {
return refCount;
}
/**
* Register a variable reference that refers to the variable bound in this let expression
* @param v the variable reference
*/
public void addReference(VariableReference v) {
refCount++;
}
/**
* Type-check the expression
*/
public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException {
// TODO: avoid repeated work if done again
// The order of events is critical here. First we ensure that the type of the
// sequence expression is established. This is used to establish the type of the variable,
// which in turn is required when type-checking the action part.
sequence = visitor.typeCheck(sequence, contextItemType);
RoleLocator role = new RoleLocator(RoleLocator.VARIABLE, getVariableQName(), 0,
visitor.getConfiguration().getNamePool());
role.setSourceLocator(this);
sequence = TypeChecker.strictTypeCheck(
sequence, requiredType, role, visitor.getStaticContext());
final TypeHierarchy th = visitor.getConfiguration().getTypeHierarchy();
final ItemType actualItemType = sequence.getItemType(th);
refineTypeInformation(actualItemType,
sequence.getCardinality(),
(sequence instanceof Literal ? ((Literal) sequence).getValue() : null),
sequence.getSpecialProperties(), visitor, this);
action = visitor.typeCheck(action, contextItemType);
return this;
}
/**
* Determine whether this expression implements its own method for static type checking
*
* @return true - this expression has a non-trivial implementation of the staticTypeCheck()
* method
*/
public boolean implementsStaticTypeCheck() {
return true;
}
/**
* Static type checking for let expressions is delegated to the expression itself,
* and is performed on the "action" expression, to allow further delegation to the branches
* of a conditional
* @param req the required type
* @param backwardsCompatible true if backwards compatibility mode applies
* @param role the role of the expression in relation to the required type
* @param visitor an expression visitor
* @return the expression after type checking (perhaps augmented with dynamic type checking code)
* @throws XPathException if failures occur, for example if the static type of one branch of the conditional
* is incompatible with the required type
*/
public Expression staticTypeCheck(SequenceType req,
boolean backwardsCompatible,
RoleLocator role, ExpressionVisitor visitor)
throws XPathException {
action = TypeChecker.staticTypeCheck(action, req, backwardsCompatible, role, visitor);
return this;
}
/**
* Perform optimisation of an expression and its subexpressions.
*
* This method is called after all references to functions and variables have been resolved
* to the declaration of the function or variable, and after all type checking has been done.
*
* @param visitor an expression visitor
* @param contextItemType the static type of "." at the point where this expression is invoked.
* The parameter is set to null if it is known statically that the context item will be undefined.
* If the type of the context item is not known statically, the argument is set to
* {@link net.sf.saxon.type.Type#ITEM_TYPE}
* @return the original expression, rewritten if appropriate to optimize execution
* @throws XPathException if an error is discovered during this phase
* (typically a type error)
*/
public Expression optimize(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException {
StaticContext env = visitor.getStaticContext();
Optimizer opt = visitor.getConfiguration().getOptimizer();
// if this is a construct of the form "let $j := EXP return $j" replace it with EXP
// Remarkably, people do write this, and it can also be produced by previous rewrites
// Note that type checks will already have been added to the sequence expression
if (action instanceof VariableReference &&
((VariableReference) action).getBinding() == this) {
return visitor.optimize(sequence, contextItemType);
}
/**
* Unless this has already been done, find and count the references to this variable
*/
// if this is an XSLT construct of the form text , try to replace
// it by