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();
}
static
void addNoAliasSetForFormal(ArgSymbol* arg,
std::vector<ArgSymbol*> notAliasingThese) {
SET_LINENO(arg);
CallExpr* c = new CallExpr(PRIM_NO_ALIAS_SET, new SymExpr(arg));
for_vector(ArgSymbol, other, notAliasingThese) {
c->insertAtTail(new SymExpr(other));
}
//
// Consider a function that takes a formal of type Record by const ref
// and that returns that value from the function. The compiler inserts
// a PRIM_MOVE operation.
//
// This work-around inserts an autoCopy to compensate
//
void ReturnByRef::updateAssignmentsFromRefArgToValue(FnSymbol* fn)
{
std::vector<CallExpr*> callExprs;
collectCallExprs(fn, callExprs);
for (size_t i = 0; i < callExprs.size(); i++)
{
CallExpr* move = callExprs[i];
if (move->isPrimitive(PRIM_MOVE) == true)
{
SymExpr* lhs = toSymExpr(move->get(1));
SymExpr* rhs = toSymExpr(move->get(2));
if (lhs != NULL && rhs != NULL)
{
VarSymbol* symLhs = toVarSymbol(lhs->symbol());
ArgSymbol* symRhs = toArgSymbol(rhs->symbol());
if (symLhs != NULL && symRhs != NULL)
{
if (isUserDefinedRecord(symLhs->type) == true &&
symRhs->type == symLhs->type)
{
if (symLhs->hasFlag(FLAG_ARG_THIS) == false &&
(symRhs->intent == INTENT_REF ||
symRhs->intent == INTENT_CONST_REF))
{
SET_LINENO(move);
CallExpr* autoCopy = NULL;
rhs->remove();
autoCopy = new CallExpr(autoCopyMap.get(symRhs->type), rhs);
move->insertAtTail(autoCopy);
}
}
}
}
}
}
}
