SequenceType::List CombineNodes::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreNodes);
result.append(CommonSequenceTypes::ZeroOrMoreNodes);
return result;
}
SequenceType::List ValueComparison::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrOneAtomicType);
result.append(CommonSequenceTypes::ZeroOrOneAtomicType);
return result;
}
SequenceType::List ElementConstructor::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ExactlyOneQName);
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List ForClause::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List ComputedNamespaceConstructor::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrOneString);
result.append(CommonSequenceTypes::ZeroOrOneString);
return result;
}
SequenceType::List RangeExpression::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrOneInteger);
result.append(CommonSequenceTypes::ZeroOrOneInteger);
return result;
}
SequenceType::List ExpressionSequence::expectedOperandTypes() const
{
SequenceType::List result;
/* ExpressionSequence is a bit strange type wise since it has an
* infinite amount of operands. */
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List Path::expectedOperandTypes() const
{
SequenceType::List result;
/* This value needs to be in sync with what we pass to
* applyFunctionConversion() in typeCheck() above.
*
* We don't have the XPTY0019 restriction when we're synthetic XSL-T code.
*/
if(m_kind == XSLTForEach)
result.append(CommonSequenceTypes::ZeroOrMoreItems);
else
result.append(CommonSequenceTypes::ZeroOrMoreNodes);
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List UserFunctionCallsite::expectedOperandTypes() const
{
SequenceType::List result;
if(m_functionDeclaration)
{
const FunctionArgument::List args(m_functionDeclaration->signature()->arguments());
const FunctionArgument::List::const_iterator end(args.constEnd());
FunctionArgument::List::const_iterator it(args.constBegin());
for(; it != end; ++it)
result.append((*it)->type());
}
else
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List FunctionCall::expectedOperandTypes() const
{
const FunctionArgument::List args(signature()->arguments());
FunctionArgument::List::const_iterator it(args.constBegin());
const FunctionArgument::List::const_iterator end(args.constEnd());
// TODO reserve/resize()
SequenceType::List result;
for(; it != end; ++it)
result.append((*it)->type());
return result;
}
SequenceType::List EvaluationCache<IsForGlobal>::expectedOperandTypes() const
{
/* Remember that EvaluationCache::typeCheck() will be called from multiple locations,
* which potentially have different type requirements. For instance, one wants a node,
* and another requires atomization and casting.
*
* Returning ZeroOrMoreItems is safe here because staticType() returns the operand's type
* and therefore the convertors like Atomizer will be parents to us, and hence only affect
* the relevant path.
*
* ZeroOrMoreItems also make sense logically since we're actually only used where the
* variable references reference us. */
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List TemplateInvoker::expectedOperandTypes() const
{
SequenceType::List result;
/* We don't return the type of the m_template->templateParameters(), we
* return the type of the @c xsl:with-param first. @em After that, we
* manually apply the parameter types in typeCheck(). */
const WithParam::Hash::const_iterator end(m_withParams.constEnd());
for(WithParam::Hash::const_iterator it(m_withParams.constBegin()); it != end; ++it)
{
/* We're not guaranteed to have a with-param, we may be using the
* default value of the xsl:param. Tunnel parameters may also play
* in. */
result.append(it.value()->type());
}
return result;
}
SequenceType::List CardinalityVerifier::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List ArgumentConverter::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List XSLTSimpleContentConstructor::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List UntypedAtomicConverter::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreAtomicTypes);
return result;
}
SequenceType::List DynamicContextStore::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List NodeSortExpression::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List CollationChecker::expectedOperandTypes() const
{
SequenceType::List list;
list.append(CommonSequenceTypes::ExactlyOneString);
return list;
}
SequenceType::List CastableAs::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreAtomicTypes);
return result;
}
SequenceType::List QNameConstructor::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ExactlyOneString);
return result;
}
SequenceType::List FirstItemPredicate::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ZeroOrMoreItems);
return result;
}
SequenceType::List StaticCompatibilityStore::expectedOperandTypes() const
{
SequenceType::List ops;
ops.append(CommonSequenceTypes::ZeroOrMoreItems);
return ops;
}
SequenceType::List AttributeNameValidator::expectedOperandTypes() const
{
SequenceType::List result;
result.append(CommonSequenceTypes::ExactlyOneQName);
return result;
}