//
// Determine the index type for a ParamForLoop.
//
// This implementation creates a range with low/high values and then
// asks for its type.
//
Type* ParamForLoop::indexType()
{
SymExpr* lse = lowExprGet();
SymExpr* hse = highExprGet();
CallExpr* range = new CallExpr("chpl_build_bounded_range",
lse->copy(), hse->copy());
Type* idxType = 0;
insertBefore(range);
resolveCall(range);
if (FnSymbol* sym = range->isResolved())
{
resolveFormals(sym);
DefExpr* formal = toDefExpr(sym->formals.get(1));
if (toArgSymbol(formal->sym)->typeExpr)
idxType = toArgSymbol(formal->sym)->typeExpr->body.tail->typeInfo();
else
idxType = formal->sym->type;
range->remove();
}
else
{
INT_FATAL("unresolved range");
}
return idxType;
}
void ResolutionCandidate::resolveTypeConstructor(CallInfo& info) {
SET_LINENO(fn);
// Ignore tuple constructors; they were generated
// with their type constructors.
if (fn->hasFlag(FLAG_PARTIAL_TUPLE) == false) {
CallExpr* typeConstructorCall = new CallExpr(astr("_type", fn->name));
for_formals(formal, fn) {
if (formal->hasFlag(FLAG_IS_MEME) == false) {
if (fn->_this->type->symbol->hasFlag(FLAG_TUPLE)) {
if (formal->instantiatedFrom != NULL) {
typeConstructorCall->insertAtTail(formal->type->symbol);
} else if (formal->hasFlag(FLAG_INSTANTIATED_PARAM)) {
typeConstructorCall->insertAtTail(paramMap.get(formal));
}
} else {
if (strcmp(formal->name, "outer") == 0 ||
formal->type == dtMethodToken) {
typeConstructorCall->insertAtTail(formal);
} else if (formal->instantiatedFrom != NULL) {
SymExpr* se = new SymExpr(formal->type->symbol);
NamedExpr* ne = new NamedExpr(formal->name, se);
typeConstructorCall->insertAtTail(ne);
} else if (formal->hasFlag(FLAG_INSTANTIATED_PARAM)) {
SymExpr* se = new SymExpr(paramMap.get(formal));
NamedExpr* ne = new NamedExpr(formal->name, se);
typeConstructorCall->insertAtTail(ne);
}
}
}
}
info.call->insertBefore(typeConstructorCall);
// If instead we call resolveCallAndCallee(typeConstructorCall)
// then the line number reported in an error would change
// e.g.: domains/deitz/test_generic_class_of_sparse_domain
// or: classes/diten/multipledestructor
resolveCall(typeConstructorCall);
INT_ASSERT(typeConstructorCall->isResolved());
resolveFunction(typeConstructorCall->resolvedFunction());
fn->_this->type = typeConstructorCall->resolvedFunction()->retType;
typeConstructorCall->remove();
}
void Resolver::visit(CallLValue& lvalue, int dummy)
{
resolveCall(*lvalue.call(), true);
}
void Resolver::visit(CallExpr& expr, int dummy)
{
resolveCall(expr, false);
}
