Changeset 0bd46fd for src/ResolvExpr


Ignore:
Timestamp:
Sep 21, 2022, 10:52:51 AM (3 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, master, pthread-emulation
Children:
7f6a7c9, e01eb4a
Parents:
20737104
Message:

Fixed several warnings

Location:
src/ResolvExpr
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified src/ResolvExpr/AlternativeFinder.cc

    r20737104 r0bd46fd  
    299299                                SemanticError( expr->location, stream.str() );
    300300                        }
    301                         alternatives = move(pruned);
     301                        alternatives = std::move(pruned);
    302302                        PRINT(
    303303                                std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
    … …  
    573573                                unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0,
    574574                                unsigned explAlt = 0 )
    575                         : parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
    576                           have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
     575                        : parent(parent), expr(expr->clone()), cost(cost), env(std::move(env)), need(std::move(need)),
     576                          have(std::move(have)), openVars(std::move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
    577577                          nextExpl(nextExpl), explAlt(explAlt) {}
    578578
    … …  
    580580                                OpenVarSet&& openVars, unsigned nextArg, Cost added )
    581581                        : parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), cost(o.cost + added),
    582                           env(move(env)), need(move(need)), have(move(have)), openVars(move(openVars)),
     582                          env(std::move(env)), need(std::move(need)), have(std::move(have)), openVars(std::move(openVars)),
    583583                          nextArg(nextArg), tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
    584584
    … …  
    707707                                                if ( unify( ttype, argType, newResult.env, newResult.need, newResult.have,
    708708                                                                newResult.openVars, indexer ) ) {
    709                                                         finalResults.push_back( move(newResult) );
     709                                                        finalResults.push_back( std::move(newResult) );
    710710                                                }
    711711
    … …  
    726726                                                if ( expl.exprs.empty() ) {
    727727                                                        results.emplace_back(
    728                                                                 results[i], move(env), copy(results[i].need),
    729                                                                 copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
     728                                                                results[i], std::move(env), copy(results[i].need),
     729                                                                copy(results[i].have), std::move(openVars), nextArg + 1, expl.cost );
    730730
    731731                                                        continue;
    … …  
    734734                                                // add new result
    735735                                                results.emplace_back(
    736                                                         i, expl.exprs.front().get(), move(env), copy(results[i].need),
    737                                                         copy(results[i].have), move(openVars), nextArg + 1,
     736                                                        i, expl.exprs.front().get(), std::move(env), copy(results[i].need),
     737                                                        copy(results[i].have), std::move(openVars), nextArg + 1,
    738738                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    739739                                        }
    … …  
    747747                        // splice final results onto results
    748748                        for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
    749                                 results.push_back( move(finalResults[i]) );
     749                                results.push_back( std::move(finalResults[i]) );
    750750                        }
    751751                        return ! finalResults.empty();
    … …  
    783783
    784784                                        results.emplace_back(
    785                                                 i, expr, move(env), move(need), move(have), move(openVars), nextArg,
     785                                                i, expr, std::move(env), std::move(need), std::move(have), std::move(openVars), nextArg,
    786786                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
    787787                                }
    … …  
    801801                                                                indexer ) ) {
    802802                                                        results.emplace_back(
    803                                                                 i, new DefaultArgExpr( cnstExpr ), move(env), move(need), move(have),
    804                                                                 move(openVars), nextArg, nTuples );
     803                                                                i, new DefaultArgExpr( cnstExpr ), std::move(env), std::move(need), std::move(have),
     804                                                                std::move(openVars), nextArg, nTuples );
    805805                                                }
    806806                                        }
    … …  
    824824                                if ( expl.exprs.empty() ) {
    825825                                        results.emplace_back(
    826                                                 results[i], move(env), move(need), move(have), move(openVars),
     826                                                results[i], std::move(env), std::move(need), std::move(have), std::move(openVars),
    827827                                                nextArg + 1, expl.cost );
    828828
    … …  
    846846                                        // add new result
    847847                                        results.emplace_back(
    848                                                 i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
     848                                                i, expr, std::move(env), std::move(need), std::move(have), std::move(openVars), nextArg + 1,
    849849                                                nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    850850                                }
    … …  
    962962                                                if ( expl.exprs.empty() ) {
    963963                                                        results.emplace_back(
    964                                                                 results[i], move(env), copy(results[i].need),
    965                                                                 copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
     964                                                                results[i], std::move(env), copy(results[i].need),
     965                                                                copy(results[i].have), std::move(openVars), nextArg + 1, expl.cost );
    966966
    967967                                                        continue;
    … …  
    970970                                                // add new result
    971971                                                results.emplace_back(
    972                                                         i, expl.exprs.front().get(), move(env), copy(results[i].need),
    973                                                         copy(results[i].have), move(openVars), nextArg + 1, 0,
     972                                                        i, expl.exprs.front().get(), std::move(env), copy(results[i].need),
     973                                                        copy(results[i].have), std::move(openVars), nextArg + 1, 0,
    974974                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    975975                                        }
    … …  
    10671067                                funcE.emplace_back( actual, indexer );
    10681068                        }
    1069                         argExpansions.insert( argExpansions.begin(), move(funcE) );
     1069                        argExpansions.insert( argExpansions.begin(), std::move(funcE) );
    10701070
    10711071                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin();
    … …  
    11161116                } // for
    11171117
    1118                 candidates = move(alternatives);
     1118                candidates = std::move(alternatives);
    11191119
    11201120                // use a new list so that alternatives are not examined by addAnonConversions twice.

  • TabularUnified src/ResolvExpr/Unify.cc

    r20737104 r0bd46fd  
    727727                };
    728728        }
    729        
     729
    730730        std::vector< ast::ptr< ast::Type > > flattenList(
    731731                const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
    … …  
    989989                                if ( isTuple && isTuple2 ) {
    990990                                        ++it; ++jt;  // skip ttype parameters before break
    991                                 } else if ( isTuple ) { 
     991                                } else if ( isTuple ) {
    992992                                        // bundle remaining params into tuple
    993993                                        pty2 = tupleFromExprs( param2, jt, params2.end(), pty->qualifiers );
    … …  
    10351035        private:
    10361036                /// Creates a tuple type based on a list of Type
    1037                
     1037
    10381038
    10391039                static bool unifyList(
    … …  
    12071207                        }
    12081208
    1209                 } else if ( common = commonType( t1, t2, env, need, have, open, widen, symtab )) {
     1209                } else if (( common = commonType( t1, t2, env, need, have, open, widen, symtab ))) {
    12101210                        // no exact unification, but common type
    12111211                        auto c = shallowCopy(common.get());
Note: See TracChangeset for help on using the changeset viewer.