Changeset b6d6e97

Timestamp:

Sep 27, 2017, 3:54:21 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

7bcb8eb

Parents:

a4477db

Message:

Add maybeFind to AlternativeFinder? to prevent excess exceptions when finding function operators

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (6 diffs)
• AlternativeFinder.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -174 +174 @@
         }
 
-        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) {
+        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) {
                 expr->accept( *this );
-                if ( alternatives.empty() ) {
+                if ( failFast && alternatives.empty() ) {
                         throw SemanticError( "No reasonable alternatives for expression ", expr );
                 }
@@ -191 +191 @@
                         AltList::iterator oldBegin = alternatives.begin();
                         pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
-                        if ( alternatives.begin() == oldBegin ) {
+                        if ( failFast && alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
                                 AltList winners;
@@ -214 +214 @@
         }
 
-        void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) {
-                find( expr, true, prune );
+        void AlternativeFinder::findWithAdjustment( Expression *expr ) {
+                find( expr, true );
+        }
+
+        void AlternativeFinder::findWithoutPrune( Expression * expr ) {
+                find( expr, true, false );
+        }
+
+        void AlternativeFinder::maybeFind( Expression * expr ) {
+                find( expr, true, true, false );
         }
 
@@ -714 +722 @@
 
                 // find function operators
+                static NameExpr *opExpr = new NameExpr( "?()" );
                 AlternativeFinder funcOpFinder( indexer, env );
-                NameExpr *opExpr = new NameExpr( "?()" );
-                try {
-                        funcOpFinder.findWithAdjustment( opExpr );
-                } catch( SemanticError &e ) {
-                        // it's ok if there aren't any defined function ops
-                }
+                // it's ok if there aren't any defined function ops
+                funcOpFinder.maybeFind( opExpr);
                 PRINT(
                         std::cerr << "known function ops:" << std::endl;
@@ -928 +933 @@
                 AlternativeFinder finder( indexer, env );
                 // don't prune here, since it's guaranteed all alternatives will have the same type
-                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
-                finder.findWithAdjustment( castExpr->get_arg(), false );
+                finder.findWithoutPrune( castExpr->get_arg() );
                 for ( Alternative & alt : finder.alternatives ) {
                         alternatives.push_back( Alternative(
@@ -1226 +1230 @@
                 // don't prune here, since it's guaranteed all alternatives will have the same type
                 // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
-                finder.findWithAdjustment( ctorExpr->get_callExpr(), false );
+                finder.findWithoutPrune( ctorExpr->get_callExpr() );
                 for ( Alternative & alt : finder.alternatives ) {
                         alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );

src/ResolvExpr/AlternativeFinder.h

@@ -34 +34 @@
           public:
                 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
-                void find( Expression *expr, bool adjust = false, bool prune = true );
+                void find( Expression *expr, bool adjust = false, bool prune = true, bool failFast = true );
                 /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
-                void findWithAdjustment( Expression *expr, bool prune = true );
+                void findWithAdjustment( Expression *expr );
+                /// Calls find with the adjust flag set and prune flag unset; pruning ensures there is at most one alternative per result type
+                void findWithoutPrune( Expression *expr );
+                /// Calls find with the adjust and prune flags set, failFast flags unset; fail fast ensures that there is at least one resulting alternative
+                void maybeFind( Expression *expr );
                 AltList &get_alternatives() { return alternatives; }