Changeset 8d7bef2 for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Mar 20, 2018, 5:12:25 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

7e4b44db

Parents:

68f9c43

Message:

First compiling build of CFA-CC with GC

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -21 +21 @@
 #include <list>                    // for _List_iterator, list, _List_const_...
 #include <map>                     // for _Rb_tree_iterator, map, _Rb_tree_c...
-#include <memory>                  // for allocator_traits<>::value_type, unique_ptr
+#include <memory>                  // for allocator_traits<>::value_type
 #include <utility>                 // for pair
 #include <vector>                  // for vector
@@ -296 +296 @@
                 // adds anonymous member interpretations whenever an aggregate value type is seen.
                 // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
-                std::unique_ptr<Expression> aggrExpr( alt.expr->clone() );
+                Expression* aggrExpr = alt.expr->clone();
                 alt.env.apply( aggrExpr->get_result() );
                 Type * aggrType = aggrExpr->get_result();
                 if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
                         aggrType = aggrType->stripReferences();
-                        aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                        aggrExpr = new CastExpr{ aggrExpr, aggrType->clone() };
                 }
 
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
-                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                        addAggMembers( structInst, aggrExpr, alt.cost+Cost::safe, alt.env, &nameExpr );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
-                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                        addAggMembers( unionInst, aggrExpr, alt.cost+Cost::safe, alt.env, &nameExpr );
                 } // if
         }
@@ -630 +630 @@
         struct ArgPack {
                 std::size_t parent;                ///< Index of parent pack
-                std::unique_ptr<Expression> expr;  ///< The argument stored here
+                Expression* expr;                  ///< The argument stored here
                 Cost cost;                         ///< The cost of this argument
                 TypeEnvironment env;               ///< Environment for this pack
@@ -677 +677 @@
                         std::list<Expression*> exprs;
                         const ArgPack* pack = this;
-                        if ( expr ) { exprs.push_front( expr.release() ); }
+                        if ( expr ) { exprs.push_front( expr ); }
                         while ( pack->tupleStart == 0 ) {
                                 pack = &packs[pack->parent];
@@ -684 +684 @@
                         }
                         // reset pack to appropriate tuple
-                        expr.reset( new TupleExpr( exprs ) );
+                        expr = new TupleExpr{ exprs };
                         tupleStart = pack->tupleStart - 1;
                         parent = pack->parent;
@@ -736 +736 @@
 
                                                 results.emplace_back(
-                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
+                                                        i, expl.exprs[results[i].nextExpl], copy(results[i].env),
                                                         copy(results[i].need), copy(results[i].have),
                                                         copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
@@ -757 +757 @@
                                                         newResult.parent = i;
                                                         std::list<Expression*> emptyList;
-                                                        newResult.expr.reset( new TupleExpr( emptyList ) );
+                                                        newResult.expr = new TupleExpr{ emptyList };
                                                         argType = newResult.expr->get_result();
                                                 } else {
@@ -764 +764 @@
                                                         newResult.cost = results[i].cost;
                                                         newResult.tupleStart = results[i].tupleStart;
-                                                        newResult.expr.reset( results[i].expr->clone() );
+                                                        newResult.expr = results[i].expr->clone();
                                                         argType = newResult.expr->get_result();
 
@@ -814 +814 @@
                                                 // add new result
                                                 results.emplace_back(
-                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
+                                                        i, expl.exprs.front(), move(env), copy(results[i].need),
                                                         copy(results[i].have), move(openVars), nextArg + 1,
                                                         nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
@@ -840 +840 @@
                         if ( results[i].hasExpl() ) {
                                 const ExplodedActual& expl = results[i].getExpl( args );
-                                Expression* expr = expl.exprs[results[i].nextExpl].get();
+                                Expression* expr = expl.exprs[results[i].nextExpl];
 
                                 TypeEnvironment env = results[i].env;
@@ -911 +911 @@
 
                                 // consider only first exploded actual
-                                Expression* expr = expl.exprs.front().get();
+                                Expression* expr = expl.exprs.front();
                                 Type* actualType = expr->get_result()->clone();
 
@@ -1014 +1014 @@
 
                                                 results.emplace_back(
-                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
+                                                        i, expl.exprs[results[i].nextExpl], copy(results[i].env),
                                                         copy(results[i].need), copy(results[i].have),
                                                         copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
@@ -1050 +1050 @@
                                                 // add new result
                                                 results.emplace_back(
-                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
+                                                        i, expl.exprs.front(), move(env), copy(results[i].need),
                                                         copy(results[i].have), move(openVars), nextArg + 1, 0,
                                                         expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
@@ -1344 +1344 @@
                         Expression * aggrExpr = agg->expr->clone();
                         referenceToRvalueConversion( aggrExpr, cost );
-                        std::unique_ptr<Expression> guard( aggrExpr );
 
                         // find member of the given type