Match
Argument::
isConvertibleTo(const Argument& target) const
{
static const Type* valueType = reflect::type<Value>();
if (*this == target) return Match::Exact;
if ((type() == valueType) ^ (target.type() == valueType))
return Match::Exact;
bool isExact = false;
if (type()->hasConverter(target.type())) {
if (target.refType() != RefType::LValue) return Match::Partial;
return Match::None;
}
if (target.refType() != RefType::Copy) {
if (!testConstConversion(isConst(), target.isConst()))
return Match::None;
}
else isExact = refType() == RefType::RValue;
if (target.refType() == RefType::LValue) {
if (target.isConst()) {}
else if (isConst()) return Match::None;
else if (refType() != RefType::LValue) return Match::None;
}
else if (target.refType() == RefType::RValue) {
if (refType() != RefType::RValue) return Match::None;
}
if (!target.type()->isParentOf(type())) return Match::None;
if (isExact) return Match::Exact;
if (isConst() == target.isConst() && refType() == target.refType())
return Match::Exact;
return Match::Partial;
}
int tesla::ArgIndex(const Argument& A) {
switch (A.type()) {
case Argument::Any:
case Argument::Constant:
return -1;
case Argument::Variable:
case Argument::Field:
case Argument::Indirect:
return A.index();
}
}
std::string tesla::BaseName(const Argument& A) {
switch (A.type()) {
case Argument::Any:
case Argument::Constant:
assert(false && "called BaseName() on a non-variable Argument");
case Argument::Variable:
return A.name();
case Argument::Indirect:
return BaseName(A.indirection());
case Argument::Field:
return BaseName(A.field().base());
}
}
void ArgumentGroup::validate_argument(const Argument & new_argument) const
{
const Option & new_option = new_argument.option();
for(argument_vector_type::const_iterator i = this->_arguments.begin(); i != this->_arguments.end(); ++i)
{
const Argument & old_argument = *i;
const Option & old_option = old_argument.option();
if(new_option.conflicts(old_option))
{
std::ostringstream os;
os << "conflicting options <" << new_option.option_string() << "> and <" << old_option.option_string() << '>';
throw ArgParserError(DEBUG_INFO, os.str());
}
if(new_option.same_dest(old_option))
{
if(new_argument.type() != old_argument.type())
{
std::ostringstream os;
os << "conflicting options <" << new_option.option_string() << "> with type " << Type::label(new_argument.type())
<< " and <" << old_option.option_string() << "> with type " << Type::label(new_argument.type());
throw ArgParserError(DEBUG_INFO, os.str());
}
if(new_argument.multiplicity() != old_argument.multiplicity())
{
std::ostringstream os;
os << "conflicting options <" << new_option.option_string() << "> with multiplicity " << new_argument.multiplicity()
<< " and <" << old_option.option_string() << "> with multiplicity " << old_argument.multiplicity();
throw ArgParserError(DEBUG_INFO, os.str());
}
if(new_argument.default_value() != old_argument.default_value())
{
std::ostringstream os;
os << "conflicting options <" << new_option.option_string() << "> with default_value " << new_argument.default_value()
<< " and <" << old_option.option_string() << "> with default_value " << old_argument.default_value();
throw ArgParserError(DEBUG_INFO, os.str());
}
}
}
}
void tst_Lookup::iface_impl_scoping()
{
const QByteArray source = "\n"
"@interface Scooping{}-(int)method1:(int)arg;-(void)method2;@end\n"
"@implementation Scooping-(int)method1:(int)arg{return arg;}@end\n";
Document::Ptr doc = Document::create("class_with_protocol_with_protocol");
doc->setUtf8Source(source);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2U);
Snapshot snapshot;
snapshot.insert(doc);
ObjCClass *iface = doc->globalSymbolAt(0)->asObjCClass();
QVERIFY(iface);
QVERIFY(iface->isInterface());
ObjCClass *impl = doc->globalSymbolAt(1)->asObjCClass();
QVERIFY(impl);
QVERIFY(!impl->isInterface());
QCOMPARE(iface->memberCount(), 2U);
QCOMPARE(impl->memberCount(), 1U);
ObjCMethod *method1Impl = impl->memberAt(0)->asObjCMethod();
QVERIFY(method1Impl);
QCOMPARE(method1Impl->identifier()->chars(), "method1");
// get the body of method1
QCOMPARE(method1Impl->memberCount(), 2U);
Argument *method1Arg = method1Impl->memberAt(0)->asArgument();
QVERIFY(method1Arg);
QCOMPARE(method1Arg->identifier()->chars(), "arg");
QVERIFY(method1Arg->type()->isIntegerType());
Block *method1Body = method1Impl->memberAt(1)->asBlock();
QVERIFY(method1Body);
const LookupContext context(doc, snapshot);
{ // verify if we can resolve "arg" in the body
QCOMPARE(method1Impl->argumentCount(), 1U);
Argument *arg = method1Impl->argumentAt(0)->asArgument();
QVERIFY(arg);
QVERIFY(arg->name());
QVERIFY(arg->name()->identifier());
QCOMPARE(arg->name()->identifier()->chars(), "arg");
QVERIFY(arg->type()->isIntegerType());
const QList<LookupItem> candidates = context.lookup(arg->name(), method1Body->enclosingScope());
QCOMPARE(candidates.size(), 1);
QVERIFY(candidates.at(0).declaration()->type()->asIntegerType());
}
Declaration *method2 = iface->memberAt(1)->asDeclaration();
QVERIFY(method2);
QCOMPARE(method2->identifier()->chars(), "method2");
{ // verify if we can resolve "method2" in the body
const QList<LookupItem> candidates = context.lookup(method2->name(), method1Body->enclosingScope());
QCOMPARE(candidates.size(), 1);
QCOMPARE(candidates.at(0).declaration(), method2);
}
}
