Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ src/ResolvExpr/CandidateFinder.cpp (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -105,5 +105,5 @@ // CandidateFinder finder{ symtab, env }; - // finder.find( arg, ResolvMode::withAdjustment() ); + // finder.find( arg, ResolveMode::withAdjustment() ); // assertf( finder.candidates.size() > 0, // "Somehow castable expression failed to find alternatives." ); @@ -974,5 +974,5 @@ // xxx - is it possible that handleTupleAssignment and main finder both produce candidates? // this means there exists ctor/assign functions with a tuple as first parameter. - ResolvMode mode = { + ResolveMode mode = { true, // adjust !untypedExpr->func.as(), // prune if not calling by name @@ -989,5 +989,5 @@ CandidateFinder opFinder( context, tenv ); // okay if there aren't any function operations - opFinder.find( opExpr, ResolvMode::withoutFailFast() ); + opFinder.find( opExpr, ResolveMode::withoutFailFast() ); PRINT( std::cerr << "known function ops:" << std::endl; @@ -1175,10 +1175,10 @@ if ( castExpr->kind == ast::CastExpr::Return ) { finder.strictMode = true; - finder.find( castExpr->arg, ResolvMode::withAdjustment() ); + finder.find( castExpr->arg, ResolveMode::withAdjustment() ); // return casts are eliminated (merely selecting an overload, no actual operation) candidates = std::move(finder.candidates); } - finder.find( castExpr->arg, ResolvMode::withAdjustment() ); + finder.find( castExpr->arg, ResolveMode::withAdjustment() ); if ( !finder.candidates.empty() ) reason.code = NoMatch; @@ -1251,5 +1251,5 @@ CandidateFinder finder( context, tenv ); // don't prune here, all alternatives guaranteed to have same type - finder.find( castExpr->arg, ResolvMode::withoutPrune() ); + finder.find( castExpr->arg, ResolveMode::withoutPrune() ); for ( CandidateRef & r : finder.candidates ) { addCandidate( @@ -1298,5 +1298,5 @@ // don't prune here, since it's guaranteed all alternatives will have the same type - finder.find( tech1.get(), ResolvMode::withoutPrune() ); + finder.find( tech1.get(), ResolveMode::withoutPrune() ); pick_alternatives(finder.candidates, false); @@ -1307,5 +1307,5 @@ std::unique_ptr fallback { ast::UntypedExpr::createDeref(loc, new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) }; // don't prune here, since it's guaranteed all alternatives will have the same type - finder.find( fallback.get(), ResolvMode::withoutPrune() ); + finder.find( fallback.get(), ResolveMode::withoutPrune() ); pick_alternatives(finder.candidates, true); @@ -1316,5 +1316,5 @@ void Finder::postvisit( const ast::UntypedMemberExpr * memberExpr ) { CandidateFinder aggFinder( context, tenv ); - aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() ); + aggFinder.find( memberExpr->aggregate, ResolveMode::withAdjustment() ); for ( CandidateRef & agg : aggFinder.candidates ) { // it's okay for the aggregate expression to have reference type -- cast it to the @@ -1475,9 +1475,9 @@ void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) { CandidateFinder finder1( context, tenv ); - finder1.find( logicalExpr->arg1, ResolvMode::withAdjustment() ); + finder1.find( logicalExpr->arg1, ResolveMode::withAdjustment() ); if ( finder1.candidates.empty() ) return; CandidateFinder finder2( context, tenv ); - finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() ); + finder2.find( logicalExpr->arg2, ResolveMode::withAdjustment() ); if ( finder2.candidates.empty() ) return; @@ -1505,5 +1505,5 @@ // candidates for condition CandidateFinder finder1( context, tenv ); - finder1.find( conditionalExpr->arg1, ResolvMode::withAdjustment() ); + finder1.find( conditionalExpr->arg1, ResolveMode::withAdjustment() ); if ( finder1.candidates.empty() ) return; @@ -1511,5 +1511,5 @@ CandidateFinder finder2( context, tenv ); finder2.allowVoid = true; - finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() ); + finder2.find( conditionalExpr->arg2, ResolveMode::withAdjustment() ); if ( finder2.candidates.empty() ) return; @@ -1517,5 +1517,5 @@ CandidateFinder finder3( context, tenv ); finder3.allowVoid = true; - finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() ); + finder3.find( conditionalExpr->arg3, ResolveMode::withAdjustment() ); if ( finder3.candidates.empty() ) return; @@ -1570,5 +1570,5 @@ CandidateFinder finder2( context, env ); - finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() ); + finder2.find( commaExpr->arg2, ResolveMode::withAdjustment() ); for ( const CandidateRef & r2 : finder2.candidates ) { @@ -1584,5 +1584,5 @@ CandidateFinder finder( context, tenv ); finder.allowVoid = true; - finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() ); + finder.find( ctorExpr->callExpr, ResolveMode::withoutPrune() ); for ( CandidateRef & r : finder.candidates ) { addCandidate( *r, new ast::ConstructorExpr{ ctorExpr->location, r->expr } ); @@ -1593,9 +1593,9 @@ // resolve low and high, accept candidates where low and high types unify CandidateFinder finder1( context, tenv ); - finder1.find( rangeExpr->low, ResolvMode::withAdjustment() ); + finder1.find( rangeExpr->low, ResolveMode::withAdjustment() ); if ( finder1.candidates.empty() ) return; CandidateFinder finder2( context, tenv ); - finder2.find( rangeExpr->high, ResolvMode::withAdjustment() ); + finder2.find( rangeExpr->high, ResolveMode::withAdjustment() ); if ( finder2.candidates.empty() ) return; @@ -1673,5 +1673,5 @@ void Finder::postvisit( const ast::UniqueExpr * unqExpr ) { CandidateFinder finder( context, tenv ); - finder.find( unqExpr->expr, ResolvMode::withAdjustment() ); + finder.find( unqExpr->expr, ResolveMode::withAdjustment() ); for ( CandidateRef & r : finder.candidates ) { // ensure that the the id is passed on so that the expressions are "linked" @@ -1699,5 +1699,5 @@ // only open for the duration of resolving the UntypedExpr. CandidateFinder finder( context, tenv, toType ); - finder.find( initExpr->expr, ResolvMode::withAdjustment() ); + finder.find( initExpr->expr, ResolveMode::withAdjustment() ); Cost minExprCost = Cost::infinity; @@ -1889,5 +1889,5 @@ } -void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) { +void CandidateFinder::find( const ast::Expr * expr, ResolveMode mode ) { // Find alternatives for expression ast::Pass finder{ *this }; @@ -2004,5 +2004,5 @@ for ( const auto & x : xs ) { out.emplace_back( context, env ); - out.back().find( x, ResolvMode::withAdjustment() ); + out.back().find( x, ResolveMode::withAdjustment() ); PRINT( Index: src/ResolvExpr/CandidateFinder.hpp =================================================================== --- src/ResolvExpr/CandidateFinder.hpp (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ src/ResolvExpr/CandidateFinder.hpp (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -17,5 +17,5 @@ #include "Candidate.hpp" -#include "ResolvMode.h" +#include "ResolveMode.hpp" #include "AST/Fwd.hpp" #include "AST/Node.hpp" @@ -43,5 +43,5 @@ /// Fill candidates with feasible resolutions for `expr` - void find( const ast::Expr * expr, ResolvMode mode = {} ); + void find( const ast::Expr * expr, ResolveMode mode = {} ); bool pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector & errors ); Index: src/ResolvExpr/CandidatePrinter.cpp =================================================================== --- src/ResolvExpr/CandidatePrinter.cpp (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ src/ResolvExpr/CandidatePrinter.cpp (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -16,4 +16,6 @@ #include "CandidatePrinter.hpp" +#include + #include "AST/Expr.hpp" #include "AST/Pass.hpp" @@ -23,6 +25,4 @@ #include "ResolvExpr/CandidateFinder.hpp" #include "ResolvExpr/Resolver.h" - -#include namespace ResolvExpr { @@ -39,5 +39,5 @@ ast::TypeEnvironment env; CandidateFinder finder( { symtab, transUnit().global }, env ); - finder.find( stmt->expr, ResolvMode::withAdjustment() ); + finder.find( stmt->expr, ResolveMode::withAdjustment() ); int count = 1; os << "There are " << finder.candidates.size() << " candidates\n"; Index: c/ResolvExpr/ResolvMode.h =================================================================== --- src/ResolvExpr/ResolvMode.h (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ (revision ) @@ -1,53 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// ResolvMode.h -- -// -// Author : Aaron B. Moss -// Created On : Mon Jun 11 13:28:00 2018 -// Last Modified By : Aaron B. Moss -// Last Modified On : Fri Oct 05 13:46:00 2018 -// Update Count : 2 -// - -#pragma once - -namespace ResolvExpr { - -/// Flag set for resolution -struct ResolvMode { - const bool adjust; ///< Adjust array and function types to pointer types? [false] - const bool prune; ///< Prune alternatives to min-cost per return type? [true] - const bool failFast; ///< Fail on no resulting alternatives? [true] - - constexpr ResolvMode(bool a, bool p, bool ff) - : adjust(a), prune(p), failFast(ff) {} - - /// Default settings - constexpr ResolvMode() : adjust(false), prune(true), failFast(true) {} - - /// With adjust flag set; turns array and function types into equivalent pointers - static constexpr ResolvMode withAdjustment() { return { true, true, true }; } - - /// With adjust flag set but prune unset; pruning ensures there is at least one alternative - /// per result type - static constexpr ResolvMode withoutPrune() { return { true, false, true }; } - - /// With adjust and prune flags set but failFast unset; failFast ensures there is at least - /// one resulting alternative - static constexpr ResolvMode withoutFailFast() { return { true, true, false }; } - - /// The same mode, but with satisfyAssns turned on; for top-level calls - ResolvMode atTopLevel() const { return { adjust, true, failFast }; } -}; - -} // namespace ResolvExpr - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/ResolvExpr/ResolveMode.hpp =================================================================== --- src/ResolvExpr/ResolveMode.hpp (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) +++ src/ResolvExpr/ResolveMode.hpp (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -0,0 +1,53 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ResolveMode.hpp -- +// +// Author : Aaron B. Moss +// Created On : Mon Jun 11 13:28:00 2018 +// Last Modified By : Aaron B. Moss +// Last Modified On : Fri Oct 05 13:46:00 2018 +// Update Count : 2 +// + +#pragma once + +namespace ResolvExpr { + +/// Flag set for resolution +struct ResolveMode { + const bool adjust; ///< Adjust array and function types to pointer types? [false] + const bool prune; ///< Prune alternatives to min-cost per return type? [true] + const bool failFast; ///< Fail on no resulting alternatives? [true] + + constexpr ResolveMode(bool a, bool p, bool ff) + : adjust(a), prune(p), failFast(ff) {} + + /// Default settings + constexpr ResolveMode() : adjust(false), prune(true), failFast(true) {} + + /// With adjust flag set; turns array and function types into equivalent pointers + static constexpr ResolveMode withAdjustment() { return { true, true, true }; } + + /// With adjust flag set but prune unset; pruning ensures there is at least one alternative + /// per result type + static constexpr ResolveMode withoutPrune() { return { true, false, true }; } + + /// With adjust and prune flags set but failFast unset; failFast ensures there is at least + /// one resulting alternative + static constexpr ResolveMode withoutFailFast() { return { true, true, false }; } + + /// The same mode, but with satisfyAssns turned on; for top-level calls + ResolveMode atTopLevel() const { return { adjust, true, failFast }; } +}; + +} // namespace ResolvExpr + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ src/ResolvExpr/Resolver.cc (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -25,5 +25,5 @@ #include "Resolver.h" #include "ResolveTypeof.h" -#include "ResolvMode.h" // for ResolvMode +#include "ResolveMode.hpp" // for ResolveMode #include "typeops.h" // for extractResultType #include "Unify.h" // for unify @@ -123,5 +123,5 @@ CandidateRef findUnfinishedKindExpression( const ast::Expr * untyped, const ResolveContext & context, const std::string & kind, - std::function pred = anyCandidate, ResolvMode mode = {} + std::function pred = anyCandidate, ResolveMode mode = {} ) { if ( ! untyped ) return nullptr; @@ -263,5 +263,5 @@ ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr }; CandidateRef choice = findUnfinishedKindExpression( - untyped, context, "", anyCandidate, ResolvMode::withAdjustment() ); + untyped, context, "", anyCandidate, ResolveMode::withAdjustment() ); // a cast expression has either 0 or 1 interpretations (by language rules); @@ -292,5 +292,5 @@ const ast::Expr * untyped, const ResolveContext & context, std::function pred = anyCandidate, - const std::string & kind = "", ResolvMode mode = {} + const std::string & kind = "", ResolveMode mode = {} ) { if ( ! untyped ) return {}; @@ -860,5 +860,5 @@ // Find all candidates for a function in canonical form - funcFinder.find( clause.target, ResolvMode::withAdjustment() ); + funcFinder.find( clause.target, ResolveMode::withAdjustment() ); if ( funcFinder.candidates.empty() ) { Index: src/ResolvExpr/module.mk =================================================================== --- src/ResolvExpr/module.mk (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ src/ResolvExpr/module.mk (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -47,5 +47,5 @@ ResolvExpr/ResolveTypeof.cc \ ResolvExpr/ResolveTypeof.h \ - ResolvExpr/ResolvMode.h \ + ResolvExpr/ResolveMode.hpp \ ResolvExpr/SatisfyAssertions.cpp \ ResolvExpr/SatisfyAssertions.hpp \ Index: src/Tuples/TupleAssignment.cc =================================================================== --- src/Tuples/TupleAssignment.cc (revision 83fd57dbde2b629bbcc22cdd6694eccab69dd48e) +++ src/Tuples/TupleAssignment.cc (revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5) @@ -13,4 +13,6 @@ // Update Count : 10 // + +#include "Tuples.h" #include // for transform @@ -224,5 +226,5 @@ // by the cast type as needed, and transfer the resulting environment. ResolvExpr::CandidateFinder finder( spotter.crntFinder.context, env ); - finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() ); + finder.find( rhsCand->expr, ResolvExpr::ResolveMode::withAdjustment() ); assert( 1 == finder.candidates.size() ); env = std::move( finder.candidates.front()->env ); @@ -345,5 +347,5 @@ try { - finder.find( expr, ResolvExpr::ResolvMode::withAdjustment() ); + finder.find( expr, ResolvExpr::ResolveMode::withAdjustment() ); } catch (...) { // No match is not failure, just that this tuple assignment is invalid.