Changes in src/ResolvExpr/AlternativeFinder.cc [0f79853:00ac42e]

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (6 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -176 +176 @@
                                                 selected[ mangleName ] = current;
                                         } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
-                                                // if one of the candidates contains a deleted identifier, can pick the other, since
-                                                // deleted expressions should not be ambiguous if there is another option that is at least as good
-                                                if ( findDeletedExpr( candidate->expr ) ) {
-                                                        // do nothing
-                                                        PRINT( std::cerr << "candidate is deleted" << std::endl; )
-                                                } else if ( findDeletedExpr( mapPlace->second.candidate->expr ) ) {
-                                                        PRINT( std::cerr << "current is deleted" << std::endl; )
-                                                        selected[ mangleName ] = current;
-                                                } else {
-                                                        PRINT(
-                                                                std::cerr << "marking ambiguous" << std::endl;
-                                                        )
-                                                        mapPlace->second.isAmbiguous = true;
-                                                }
+                                                PRINT(
+                                                        std::cerr << "marking ambiguous" << std::endl;
+                                                )
+                                                mapPlace->second.isAmbiguous = true;
                                         } else {
                                                 PRINT(
@@ -345 +335 @@
                 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
                         // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
-                        auto val = constantExpr->intValue();
+                        // xxx - this should be improved by memoizing the value of constant exprs
+                        // during parsing and reusing that information here.
+                        std::stringstream ss( constantExpr->get_constant()->get_value() );
+                        int val = 0;
                         std::string tmp;
-                        if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
+                        if ( ss >> val && ! (ss >> tmp) ) {
+                                if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
+                                        alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
+                                } // if
+                        } // if
+                } else if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
+                        // xxx - temporary hack until 0/1 are int constants
+                        if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
+                                std::stringstream ss( nameExpr->get_name() );
+                                int val;
+                                ss >> val;
                                 alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
-                        } // if
+                        }
                 } // if
         }
@@ -436 +439 @@
                                         return Cost::infinity;
                                 }
-                        }
-                        if ( DefaultArgExpr * def = dynamic_cast< DefaultArgExpr * >( *actualExpr ) ) {
-                                // default arguments should be free - don't include conversion cost.
-                                // Unwrap them here because they are not relevant to the rest of the system.
-                                *actualExpr = def->expr;
-                                ++formal;
-                                continue;
                         }
                         Type * formalType = (*formal)->get_type();
@@ -615 +611 @@
         ConstantExpr* getDefaultValue( Initializer* init ) {
                 if ( SingleInit* si = dynamic_cast<SingleInit*>( init ) ) {
-                        if ( CastExpr* ce = dynamic_cast<CastExpr*>( si->value ) ) {
-                                return dynamic_cast<ConstantExpr*>( ce->arg );
-                        } else {
-                                return dynamic_cast<ConstantExpr*>( si->value );
+                        if ( CastExpr* ce = dynamic_cast<CastExpr*>( si->get_value() ) ) {
+                                return dynamic_cast<ConstantExpr*>( ce->get_arg() );
                         }
                 }
@@ -879 +873 @@
                                                                 indexer ) ) {
                                                         results.emplace_back(
-                                                                i, new DefaultArgExpr( cnstExpr ), move(env), move(need), move(have),
+                                                                i, cnstExpr, move(env), move(need), move(have),
                                                                 move(openVars), nextArg, nTuples );
                                                 }
@@ -1071 +1065 @@
                 funcFinder.findWithAdjustment( untypedExpr->function );
                 // if there are no function alternatives, then proceeding is a waste of time.
-                // xxx - findWithAdjustment throws, so this check and others like it shouldn't be necessary.
                 if ( funcFinder.alternatives.empty() ) return;