Expression::Ptr TypeAvailableFN::typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType) { m_schemaTypeFactory = context->schemaDefinitions(); return StaticNamespacesContainer::typeCheck(context, reqType); }
Expression::Ptr DefaultCollationFN::typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType) { return wrapLiteral(AtomicString::fromValue(context->defaultCollation().toString()), context, this)->typeCheck(context, reqType); }
Expression::Ptr ExpressionFactory::createExpression(const QString &expr, const StaticContext::Ptr &context, const LanguageAccent lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI) { pDebug() << Q_FUNC_INFO << queryURI; Q_ASSERT(context); Q_ASSERT(requiredType); Q_ASSERT(queryURI.isValid()); OptimizationPasses::Coordinator::init(); ParserContext::Ptr info(new ParserContext(context, lang, Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI)))); const int bisonRetval = XPathparse(info.data()); Q_ASSERT_X(bisonRetval == 0, Q_FUNC_INFO, "We shouldn't be able to get an error, because we throw exceptions."); Q_UNUSED(bisonRetval); /* Needed when not compiled in debug mode, since bisonRetval won't * be used in the Q_ASSERT_X above. */ Expression::Ptr result(info->queryBody); if(!result) { context->error(QtXmlPatterns::tr("A library module cannot be evaluated " "directly. It must be imported from a " "main module."), ReportContext::XPST0003, QSourceLocation(queryURI, 1, 1)); } /* Here, we type check user declared functions and global variables. This means * that variables and functions that are not used are type checked(which they otherwise * wouldn't have been), and those which are used, are type-checked twice, unfortunately. */ const UserFunction::List::const_iterator end(info->userFunctions.constEnd()); UserFunction::List::const_iterator it(info->userFunctions.constBegin()); for(; it != end; ++it) { pDebug() << "----- User Function Typecheck -----"; registerLastPath((*it)->body()); /* We will most likely call body()->typeCheck() again, once for each callsite. That is, it will * be called from UserFunctionCallsite::typeCheck(), which will be called indirectly when * we check the query body. */ const Expression::Ptr typeCheck((*it)->body()->typeCheck(context, (*it)->signature()->returnType())); /* We don't have to call (*it)->setBody(typeCheck) here since it's only used directly below. */ processTreePass(typeCheck, UserFunctionTypeCheck); pDebug() << "------------------------------"; pDebug() << "----- User Function Compress -----"; const Expression::Ptr comp(typeCheck->compress(context)); (*it)->setBody(comp); processTreePass(comp, UserFunctionCompression); pDebug() << "------------------------------"; } const VariableDeclaration::Stack::const_iterator vend(info->variables.constEnd()); VariableDeclaration::Stack::const_iterator vit(info->variables.constBegin()); for(; vit != vend; ++vit) { Q_ASSERT(*vit); /* If it's already used, it will be typeChecked later on. */ if((*vit)->isUsed() || (*vit)->type == VariableDeclaration::ExternalVariable) continue; pDebug() << "----- Global Variable Typecheck -----"; Q_ASSERT((*vit)->expression()); /* We supply ZeroOrMoreItems, meaning the variable can evaluate to anything. */ // FIXME which is a source to bugs // TODO What about compressing variables? const Expression::Ptr nev((*vit)->expression()->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems)); processTreePass(nev, GlobalVariableTypeCheck); pDebug() << "------------------------------"; } pDebug() << "----- Initial AST build. -----"; processTreePass(result, QueryBodyInitial); pDebug() << "------------------------------"; pDebug() << "----- Type Check -----"; registerLastPath(result); result->rewrite(result, result->typeCheck(context, requiredType), context); processTreePass(result, QueryBodyTypeCheck); pDebug() << "------------------------------"; pDebug() << "----- Compress -----"; result->rewrite(result, result->compress(context), context); processTreePass(result, QueryBodyCompression); pDebug() << "------------------------------"; return result; }
Expression::Ptr StaticBaseURIFN::typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType) { /* Our base URI can never be undefined. */ return wrapLiteral(toItem(AnyURI::fromValue(context->baseURI())), context, this)->typeCheck(context, reqType); }
Expression::Ptr TypeChecker::verifyType(const Expression::Ptr &operand, const SequenceType::Ptr &reqSeqType, const StaticContext::Ptr &context, const ReportContext::ErrorCode code, const Options options) { 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 neccessarily 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; }