Changeset eef8dfb for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Jan 7, 2021, 2:55:57 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

58fe85a

Parents:

bdfc032 (diff), 44e37ef (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into dkobets-vector

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -131 +131 @@
 
         void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
-                Indenter indent = { indentAmt };
-                for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
-                        i->print( os, indent );
-                        os << std::endl;
+                std::vector<std::string> sorted;
+                sorted.reserve(list.size());
+                for(const auto & c : list) {
+                        std::stringstream ss;
+                        c.print( ss, indentAmt );
+                        sorted.push_back(ss.str());
+                }
+
+                std::sort(sorted.begin(), sorted.end());
+
+                for ( const auto & s : sorted ) {
+                        os << s << std::endl;
                 }
         }
@@ -251 +259 @@
                         SemanticError( expr, "No reasonable alternatives for expression " );
                 }
-                if ( mode.satisfyAssns || mode.prune ) {
+                if ( mode.prune ) {
                         // trim candidates just to those where the assertions resolve
                         // - necessary pre-requisite to pruning
@@ -1216 +1224 @@
                         unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
                                 haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),
-                                indexer, alt.env );
+                        Cost thisCost =
+                                castExpr->isGenerated
+                                ? conversionCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),   indexer, alt.env )
+                                : castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(), indexer, alt.env );
                         PRINT(
                                 std::cerr << "working on cast with result: " << castExpr->result << std::endl;
@@ -1292 +1302 @@
 
                 try {
-                        // Attempt 1 : turn (thread&)X into (thread_desc&)X.__thrd
+                        // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd
                         // Clone is purely for memory management
                         std::unique_ptr<Expression> tech1 { new UntypedMemberExpr(new NameExpr(castExpr->concrete_target.field), castExpr->arg->clone()) };
@@ -1303 +1313 @@
                 } catch(SemanticErrorException & ) {}
 
-                // Fallback : turn (thread&)X into (thread_desc&)get_thread(X)
+                // Fallback : turn (thread&)X into ($thread&)get_thread(X)
                 std::unique_ptr<Expression> fallback { UntypedExpr::createDeref( new UntypedExpr(new NameExpr(castExpr->concrete_target.getter), { castExpr->arg->clone() })) };
                 // don't prune here, since it's guaranteed all alternatives will have the same type
@@ -1698 +1708 @@
 
                                 // unification run for side-effects
-                                unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                bool canUnify = unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                (void) canUnify;
                                 // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?
 
-                                Cost thisCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
+                                Cost thisCost = computeConversionCost( alt.expr->result, toType, alt.expr->get_lvalue(),
                                         indexer, newEnv );
+
+                                PRINT(
+                                        Cost legacyCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
+                                                indexer, newEnv );
+                                        std::cerr << "Considering initialization:";
+                                        std::cerr << std::endl << "  FROM: "; alt.expr->result->print(std::cerr);
+                                        std::cerr << std::endl << "  TO: ";   toType          ->print(std::cerr);
+                                        std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                        std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                        std::cerr << std::endl << "  New cost " << thisCost;
+                                        std::cerr << std::endl;
+                                )
+
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away