Changeset 954c954 for src/ResolvExpr/CandidateFinder.cpp

Timestamp:

Sep 24, 2020, 3:56:16 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

6cc913e

Parents:

eccb14d

Message:

Move function argument and return variable declarations from FunctionType? to FunctionDecl?

File:

• src/ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -188 +188 @@
 
                         // mark conversion cost and also specialization cost of param type
-                        const ast::Type * paramType = (*param)->get_type();
+                        // const ast::Type * paramType = (*param)->get_type();
                         cand->expr = ast::mutate_field_index(
                                 appExpr, &ast::ApplicationExpr::args, i,
                                 computeExpressionConversionCost(
-                                        args[i], paramType, symtab, cand->env, convCost ) );
-                        convCost.decSpec( specCost( paramType ) );
+                                        args[i], *param, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( *param ) );
                         ++param;  // can't be in for-loop update because of the continue
                 }
@@ -698 +698 @@
                         if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
                                 // attempt to narrow based on expected target type
-                                const ast::Type * returnType = funcType->returns.front()->get_type();
+                                const ast::Type * returnType = funcType->returns.front();
                                 if ( ! unify(
                                         returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
@@ -712 +712 @@
                         std::size_t genStart = 0;
 
-                        for ( const ast::DeclWithType * param : funcType->params ) {
-                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
+                        // xxx - how to handle default arg after change to ftype representation?
+                        if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
+                                if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
+                                        // function may have default args only if directly calling by name
+                                        // must use types on candidate however, due to RenameVars substitution
+                                        auto nParams = funcType->params.size();
+
+                                        for (size_t i=0; i<nParams; ++i) {
+                                                auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
+                                                if (!instantiateArgument(
+                                                        funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                        }
+                                        goto endMatch;
+                                }
+                        }
+                        for ( const auto & param : funcType->params ) {
                                 // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
+                                // no default args for indirect calls
                                 if ( ! instantiateArgument(
-                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
-                        }
-
+                                        param, nullptr, args, results, genStart, symtab ) ) return;
+                        }
+
+                        endMatch:
                         if ( funcType->isVarArgs ) {
                                 // append any unused arguments to vararg pack