Changeset 4a89b52 for src

Timestamp:

Nov 30, 2023, 2:41:11 PM (6 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

d787828d

Parents:

83fd57d

Message:

Renamed ResolvMode? to ResolveMode?. This is less consistent with the namespace, but is more consistent with almost everything else.

Location:

src

Files:

• ResolvExpr/CandidateFinder.cpp (modified) (19 diffs)
• ResolvExpr/CandidateFinder.hpp (modified) (2 diffs)
• ResolvExpr/CandidatePrinter.cpp (modified) (3 diffs)
• ResolvExpr/ResolveMode.hpp (moved) (moved from src/ResolvExpr/ResolvMode.h) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• ResolvExpr/module.mk (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (3 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -105 +105 @@
 
                         // 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 +974 @@
                 // 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<ast::NameExpr>(), // prune if not calling by name
@@ -989 +989 @@
                 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 +1175 @@
                 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 +1251 @@
                 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 +1298 @@
 
                         // 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 +1307 @@
                 std::unique_ptr<const ast::Expr> 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 +1316 @@
         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 +1475 @@
         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 +1505 @@
                 // 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 +1511 @@
                 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 +1517 @@
                 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 +1570 @@
 
                 CandidateFinder finder2( context, env );
-                finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
+                finder2.find( commaExpr->arg2, ResolveMode::withAdjustment() );
 
                 for ( const CandidateRef & r2 : finder2.candidates ) {
@@ -1584 +1584 @@
                 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 +1593 @@
                 // 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 +1673 @@
         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 +1699 @@
                         // 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 +1889 @@
 }
 
-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> finder{ *this };
@@ -2004 +2004 @@
         for ( const auto & x : xs ) {
                 out.emplace_back( context, env );
-                out.back().find( x, ResolvMode::withAdjustment() );
+                out.back().find( x, ResolveMode::withAdjustment() );
 
                 PRINT(

src/ResolvExpr/CandidateFinder.hpp

@@ -17 +17 @@
 
 #include "Candidate.hpp"
-#include "ResolvMode.h"
+#include "ResolveMode.hpp"
 #include "AST/Fwd.hpp"
 #include "AST/Node.hpp"
@@ -43 +43 @@
 
         /// 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<std::string> & errors );
 

src/ResolvExpr/CandidatePrinter.cpp

@@ -16 +16 @@
 #include "CandidatePrinter.hpp"
 
+#include <iostream>
+
 #include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
@@ -23 +25 @@
 #include "ResolvExpr/CandidateFinder.hpp"
 #include "ResolvExpr/Resolver.h"
-
-#include <iostream>
 
 namespace ResolvExpr {
@@ -39 +39 @@
                 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";

src/ResolvExpr/ResolveMode.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ResolvMode.h --
+// ResolveMode.hpp --
 //
 // Author           : Aaron B. Moss
@@ -19 +19 @@
 
 /// Flag set for resolution
-struct ResolvMode {
+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 ResolvMode(bool a, bool p, bool ff)
+        constexpr ResolveMode(bool a, bool p, bool ff)
         : adjust(a), prune(p), failFast(ff) {}
 
         /// Default settings
-        constexpr ResolvMode() : adjust(false), prune(true), failFast(true) {}
+        constexpr ResolveMode() : 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 }; }
+        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 ResolvMode withoutPrune() { return { true, false, true }; }
+        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 ResolvMode withoutFailFast() { return { true, true, false }; }
+        static constexpr ResolveMode withoutFailFast() { return { true, true, false }; }
 
         /// The same mode, but with satisfyAssns turned on; for top-level calls
-        ResolvMode atTopLevel() const { return { adjust, true, failFast }; }
+        ResolveMode atTopLevel() const { return { adjust, true, failFast }; }
 };
 

src/ResolvExpr/Resolver.cc

@@ -25 +25 @@
 #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 +123 @@
                 CandidateRef findUnfinishedKindExpression(
                         const ast::Expr * untyped, const ResolveContext & context, const std::string & kind,
-                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
+                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolveMode mode = {}
                 ) {
                         if ( ! untyped ) return nullptr;
@@ -263 +263 @@
                 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 +292 @@
                         const ast::Expr * untyped, const ResolveContext & context,
                         std::function<bool(const Candidate &)> pred = anyCandidate,
-                        const std::string & kind = "", ResolvMode mode = {}
+                        const std::string & kind = "", ResolveMode mode = {}
                 ) {
                         if ( ! untyped ) return {};
@@ -860 +860 @@
 
                         // 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() ) {

src/ResolvExpr/module.mk

@@ -47 +47 @@
       ResolvExpr/ResolveTypeof.cc \
       ResolvExpr/ResolveTypeof.h \
-      ResolvExpr/ResolvMode.h \
+      ResolvExpr/ResolveMode.hpp \
       ResolvExpr/SatisfyAssertions.cpp \
       ResolvExpr/SatisfyAssertions.hpp \

src/Tuples/TupleAssignment.cc

@@ -13 +13 @@
 // Update Count     : 10
 //
+
+#include "Tuples.h"
 
 #include <algorithm>                       // for transform
@@ -224 +226 @@
                                 // 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 +347 @@
 
                         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.