QPatternist::TypeChecker Class Reference

Contains functions that applies Function Conversion Rules and other kinds of compile-time type checking tasks. More...

#include <qtypechecker_p.h>

Public Types
enum	Option { AutomaticallyConvert = 1, CheckFocus = 2, GeneratePromotion }
typedef QFlags< Option >	Options

Static Public Functions
static Expression::Ptr	applyFunctionConversion (const Expression::Ptr &operand, const SequenceType::Ptr &reqType, const StaticContext::Ptr &context, const ReportContext::ErrorCode code=ReportContext::XPTY0004, const Options=Options(AutomaticallyConvert|CheckFocus))
	Builds a pipeline of artificial AST nodes that ensures operand conforms to the type reqType by applying the Function Conversion Rules. More...

Private Functions
	TypeChecker ()

Static Private Functions
static bool	promotionPossible (const ItemType::Ptr &fromType, const ItemType::Ptr &toType, const StaticContext::Ptr &context)
static Expression::Ptr	typeCheck (Expression *const op, const StaticContext::Ptr &context, const SequenceType::Ptr &reqType)
static Expression::Ptr	verifyType (const Expression::Ptr &operand, const SequenceType::Ptr &reqSeqType, const StaticContext::Ptr &context, const ReportContext::ErrorCode code, const Options options)
	Implements the type checking and promotion part of the Function Conversion Rules. More...
static QString	wrongType (const NamePool::Ptr &np, const ItemType::Ptr &reqType, const ItemType::Ptr &opType)
	Centralizes a message-string to reduce work for translators and increase consistency. More...

Detailed Description

Contains functions that applies Function Conversion Rules and other kinds of compile-time type checking tasks.

Author

Frans Englich frans.nosp@m..eng.nosp@m.lich@.nosp@m.noki.nosp@m.a.com

Definition at line 71 of file qtypechecker_p.h.

Typedefs

Options

typedef QFlags<Option> QPatternist::TypeChecker::Options

Definition at line 111 of file qtypechecker_p.h.

Enumerations

Option

enum QPatternist::TypeChecker::Option

Enumerator
AutomaticallyConvert	When set, the function conversion rules are applied. For instance, this is type promotion and conversions from xs:untypedAtomic to xs:date. This is done for function calls, but not when binding an expression to a variable.
CheckFocus	Whether the focus should be checked or not. Sometimes the focus is unknown at the time applyFunctionConversion() is called, and therefore it is of interest to post pone the check to later on.
GeneratePromotion	When applyFunctionConversion() is passed AutomaticallyConvert and promotion is required, such as from xs:integer to xs:float, there will be no conversion performed, with the assumption that the receiver will call Numeric::toFloat() or similar. However, when GeneratePromotion is set, code will be generated that performs this conversion regardless of what any receiver do. This is useful in the case where one Expression only pipes the result of another. The only known case of that as of this writing is when UserFunctionCallsite evaluates its body.

Definition at line 74 of file qtypechecker_p.h.

        {
            AutomaticallyConvert = 1,

            CheckFocus = 2,

            GeneratePromotion
        };

Constructors and Destructors

TypeChecker()

QPatternist::TypeChecker::TypeChecker ( )

inlineprivate

No implementation is provided for this constructor. This class is not supposed to be instantiated.

Functions

applyFunctionConversion()

Expression::Ptr TypeChecker::applyFunctionConversion ( const Expression::Ptr &  operand, const SequenceType::Ptr &  reqType, const StaticContext::Ptr &  context, const ReportContext::ErrorCode  code = ReportContext::XPTY0004, const Options  options = Options(AutomaticallyConvert | CheckFocus)  )

static

Builds a pipeline of artificial AST nodes that ensures operand conforms to the type reqType by applying the Function Conversion Rules.

This new Expression is returned, or, if no conversions were necessary, operand as it is.

applyFunctionConversion() also performs various checks, such as if operand needs the focus and that the focus is defined in the context. These checks are largely guided by operand's Expression::properties().

See also

XML Path Language (XPath) 2.0, 3.1.5 Function Calls, more specifically the Function Conversion Rules

Definition at line 67 of file qtypechecker.cpp.

Referenced by QPatternist::Validate::create(), QPatternist::pushVariable(), QPatternist::resolveVariable(), QPatternist::TreatAs::typeCheck(), QPatternist::Path::typeCheck(), QPatternist::Expression::typeCheck(), QPatternist::typeCheckTemplateBody(), and QPatternist::yyparse().

{
    Q_ASSERT_X(!ReportContext::codeToString(code).isEmpty(), Q_FUNC_INFO,
               "This test ensures 'code' exists, otherwise codeToString() would assert.");
    Q_ASSERT(operand);
    Q_ASSERT(reqType);
    Q_ASSERT(context);

    /* Do it in two steps: verify type, and then cardinality. */
    const Expression::Ptr cardVerified(CardinalityVerifier::verifyCardinality(operand, reqType->cardinality(), context, code));
    return verifyType(cardVerified, reqType, context, code, options);
}

promotionPossible()

bool TypeChecker::promotionPossible ( const ItemType::Ptr &  fromType, const ItemType::Ptr &  toType, const StaticContext::Ptr &  context  )

staticprivate

Determines whether type promotion is possible from one type to another. False is returned when a promotion is not possible or if a promotion is not needed(as when the types are identical), since that can be considered to not be type promotion.

Returns

true if fromType can be promoted to toType.

See also

XML Path Language (XPath) 2.0, B.1 Type Promotion

Definition at line 84 of file qtypechecker.cpp.

Referenced by verifyType().

{
    /* These types can be promoted to xs:string. xs:untypedAtomic should be
     * cast when interpreting it formally, but implementing it as a promotion
     * gives the same result(and is faster). */
    if(*toType == *BuiltinTypes::xsString &&
       (BuiltinTypes::xsUntypedAtomic->xdtTypeMatches(fromType) ||
       BuiltinTypes::xsAnyURI->xdtTypeMatches(fromType)))
        return true;

    if(*toType == *BuiltinTypes::xsDouble &&
       BuiltinTypes::numeric->xdtTypeMatches(fromType))
    {
        /* Any numeric can be promoted to xs:double. */
        return true;
    }

    /* xs:decimal/xs:integer can be promoted to xs:float. */
    if(*toType == *BuiltinTypes::xsFloat && BuiltinTypes::xsDecimal->xdtTypeMatches(fromType))

    {
        context->warning(QtXmlPatterns::tr("Promoting %1 to %2 may cause loss of precision.")
                                   .arg(formatType(context->namePool(), fromType))
                                   .arg(formatType(context->namePool(), BuiltinTypes::xsFloat)));
        return true;
    }

    return false;
}

typeCheck()

Expression::Ptr TypeChecker::typeCheck ( Expression *const  op, const StaticContext::Ptr &  context, const SequenceType::Ptr &  reqType  )

inlinestaticprivate

Definition at line 116 of file qtypechecker.cpp.

Referenced by verifyType().

{
    return Expression::Ptr(op->typeCheck(context, reqType));
}

verifyType()

Expression::Ptr TypeChecker::verifyType ( const Expression::Ptr &  operand, const SequenceType::Ptr &  reqSeqType, const StaticContext::Ptr &  context, const ReportContext::ErrorCode  code, const Options  options  )

staticprivate

Implements the type checking and promotion part of the Function Conversion Rules.

Definition at line 123 of file qtypechecker.cpp.

Referenced by applyFunctionConversion().

{
    const ItemType::Ptr reqType(reqSeqType->itemType());
    const Expression::Properties props(operand->properties());

    /* If operand requires a focus, do the necessary type checking for that. */
    if(props.testFlag(Expression::RequiresFocus) && options.testFlag(CheckFocus))
    {
        const ItemType::Ptr contextType(context->contextItemType());
        if(contextType)
        {
            if(props.testFlag(Expression::RequiresContextItem))
            {
                Q_ASSERT_X(operand->expectedContextItemType(), Q_FUNC_INFO,
                           "When the Expression sets the RequiresContextItem property, it must "
                           "return a type in expectedContextItemType()");
                const ItemType::Ptr expectedContextType(operand->expectedContextItemType());

                /* Allow the empty sequence. We don't want to trigger XPTY0020 on ()/... . */
                if(!expectedContextType->xdtTypeMatches(contextType) && contextType != CommonSequenceTypes::Empty)
                {
                    context->error(wrongType(context->namePool(), operand->expectedContextItemType(), contextType),
                                            ReportContext::XPTY0020, operand.data());
                    return operand;
                }
            }
        }
        else
        {
            context->error(QtXmlPatterns::tr("The focus is undefined."), ReportContext::XPDY0002, operand.data());
            return operand;
        }
    }

    SequenceType::Ptr operandSeqType(operand->staticType());
    ItemType::Ptr operandType(operandSeqType->itemType());

    /* This returns the operand if the types are identical or if operandType
     * is a subtype of reqType. */
    if(reqType->xdtTypeMatches(operandType) || *operandType == *CommonSequenceTypes::Empty)
        return operand;

    /* Since we haven't exited yet, it means that the operandType is a super type
     * of reqType, and that there hence is a path down to it through the
     * type hierachy -- but that doesn't necessarily mean that a up-cast(down the
     * hierarchy) would succeed. */

    Expression::Ptr result(operand);

    if(reqType->isAtomicType())
    {
        const Expression::ID opID = operand->id();
        if((opID == Expression::IDArgumentReference ||
            (opID == Expression::IDCardinalityVerifier && operand->operands().first()->is(Expression::IDArgumentReference)))
           && *BuiltinTypes::item == *operandType)
            return Expression::Ptr(new ArgumentConverter(result, reqType));

        if(!operandType->isAtomicType())
        {
            result = Expression::Ptr(new Atomizer(result));
            /* The atomizer might know more about the type. */
            operandType = result->staticType()->itemType();
        }

        if(reqType->xdtTypeMatches(operandType))
        {
            /* Atomization was sufficient. Either the expected type is xs:anyAtomicType
             * or the type the Atomizer knows it returns, matches the required type. */
            return result;
        }

        const bool compatModeEnabled = context->compatModeEnabled();

        if((options.testFlag(AutomaticallyConvert) && BuiltinTypes::xsUntypedAtomic->xdtTypeMatches(operandType)) ||
           (compatModeEnabled && BuiltinTypes::xsString->xdtTypeMatches(reqType)))
        {
            if(*reqType == *BuiltinTypes::numeric)
            {
                result = typeCheck(new UntypedAtomicConverter(result, BuiltinTypes::xsDouble, code),
                                   context, reqSeqType);
            }
            else
                result = typeCheck(new UntypedAtomicConverter(result, reqType, code), context, reqSeqType);

            /* The UntypedAtomicConverter might know more about the type, so reload. */
            operandType = result->staticType()->itemType();
        }
        else if(compatModeEnabled && *reqType == *BuiltinTypes::xsDouble)
        {
            const FunctionFactory::Ptr functions(context->functionSignatures());
            Expression::List numberArgs;
            numberArgs.append(operand);

            result = functions->createFunctionCall(QXmlName(StandardNamespaces::fn, StandardLocalNames::number),
                                                   numberArgs,
                                                   context,
                                                   operand.data())->typeCheck(context, reqSeqType);
            operandType = result->staticType()->itemType();
            context->wrapExpressionWith(operand.data(), result);
        }

        if(reqType->xdtTypeMatches(operandType))
            return result;

        /* Test if promotion will solve it; the xdtTypeMatches didn't
         * do that. */
        if(options.testFlag(AutomaticallyConvert) && promotionPossible(operandType, reqType, context))
        {
            if(options.testFlag(GeneratePromotion))
                return Expression::Ptr(new UntypedAtomicConverter(result, reqType));
            else
                return result;
        }

        if(operandType->xdtTypeMatches(reqType))
        {
            /* For example, operandType is numeric, and reqType is xs:integer. */
            return Expression::Ptr(new ItemVerifier(result, reqType, code));
        }
        else
        {
            context->error(wrongType(context->namePool(), reqType, operandType), code, operand.data());
            return result;
        }
    }
    else if(reqType->isNodeType())
    {

        ReportContext::ErrorCode myCode;

        if(*reqType == *CommonSequenceTypes::EBV->itemType())
            myCode = ReportContext::FORG0006;
        else
            myCode = code;

        /* empty-sequence() is considered valid because it's ok to do
         * for example nilled( () ). That is, to pass an empty sequence to a
         * function requiring for example node()?. */
        if(*operandType == *CommonSequenceTypes::Empty)
            return result;
        else if(!operandType->xdtTypeMatches(reqType))
        {
            context->error(wrongType(context->namePool(), reqType, operandType), myCode, operand.data());
            return result;
        }

        /* Operand must be an item. Thus, the sequence can contain both
         * nodes and atomic values: we have to verify. */
        return Expression::Ptr(new ItemVerifier(result, reqType, myCode));
    }
    else
    {
        Q_ASSERT(*reqType == *CommonSequenceTypes::Empty);

        /* element() doesn't match empty-sequence(), but element()* does. */
        if(!reqType->xdtTypeMatches(operandType) &&
           !operandSeqType->cardinality().allowsEmpty())
        {
            context->error(wrongType(context->namePool(), reqType, operandType),
                                     code, operand.data());
            return result;
        }
    }

    /* This line should be reached if required type is
     * EBVType, and the operand is compatible. */
    return result;
}

wrongType()

QString TypeChecker::wrongType ( const NamePool::Ptr &  np, const ItemType::Ptr &  reqType, const ItemType::Ptr &  opType  )

inlinestaticprivate

Centralizes a message-string to reduce work for translators and increase consistency.

Definition at line 59 of file qtypechecker.cpp.

Referenced by verifyType().

{
    return QtXmlPatterns::tr("Required type is %1, but %2 was found.")
              .arg(formatType(np, reqType), formatType(np, opType));
}

---

The documentation for this class was generated from the following files:

• /src/xmlpatterns/type/qtypechecker_p.h
• /src/xmlpatterns/type/qtypechecker.cpp