Changes in src/ResolvExpr/CandidateFinder.cpp [954c954:4ef08f7]

File:

• src/ResolvExpr/CandidateFinder.cpp (modified) (5 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], *param, symtab, cand->env, convCost ) );
-                        convCost.decSpec( specCost( *param ) );
+                                        args[i], paramType, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( paramType ) );
                         ++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();
+                                const ast::Type * returnType = funcType->returns.front()->get_type();
                                 if ( ! unify(
                                         returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
@@ -712 +712 @@
                         std::size_t genStart = 0;
 
-                        // 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 ) {
+                        for ( const ast::DeclWithType * param : funcType->params ) {
+                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
                                 // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
-                                // no default args for indirect calls
                                 if ( ! instantiateArgument(
-                                        param, nullptr, args, results, genStart, symtab ) ) return;
-                        }
-
-                        endMatch:
+                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
+                        }
+
                         if ( funcType->isVarArgs ) {
                                 // append any unused arguments to vararg pack
@@ -832 +816 @@
                 /// Adds aggregate member interpretations
                 void addAggMembers(
-                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
+                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
                         const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
@@ -1279 +1263 @@
 
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
-                        const ast::BaseInstType * aggInst;
+                        const ast::ReferenceToType * aggInst;
                         if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
                         else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;