Changeset b8524ca for src/Tuples

Timestamp:

Jun 20, 2019, 6:50:42 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

9af00d23

Parents:

234b1cb

Message:

new AST porting

• mostly InitTweak? autogeneration
• added some convenience methods
  • nullptr assignment for ast::ptr
  • convenience wrapper ctors for AddressExpr?, CastExpr? that draw location from first arg

Location:

src/Tuples

Files:

• Explode.cc (modified) (4 diffs)
• Explode.h (modified) (1 diff)
• TupleAssignment.cc (modified) (4 diffs)

src/Tuples/Explode.cc

@@ -133 +133 @@
                         if ( first ) {
                                 castAdded = true;
-                                const ast::Expr * tuple = new ast::TupleExpr(
-                                        tupleExpr->location, std::move( exprs ) );
-                                return new ast::CastExpr( tuple->location,
-                                        tuple, new ast::ReferenceType( tuple->result.get(), ast::CV::Qualifiers() ) );
+                                const ast::Expr * tuple = new ast::TupleExpr{
+                                        tupleExpr->location, std::move( exprs ) };
+                                return new ast::CastExpr{ tuple, new ast::ReferenceType{ tuple->result } };
                         } else {
                                 return new ast::TupleExpr( tupleExpr->location, std::move( exprs ) );
@@ -145 +144 @@
                 } else {
                         castAdded = true;
-                        return new ast::CastExpr( expr->location, expr,
-                                new ast::ReferenceType( expr->result, ast::CV::Qualifiers() ) );
+                        return new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } };
                 }
         }
@@ -164 +162 @@
                         castAdded = false;
                         const ast::Type * newType = getReferenceBase( newNode->result );
-                        return new ast::CastExpr( newNode->location, node, newType );
+                        return new ast::CastExpr{ newNode->location, node, newType };
                 }
                 return newNode;
@@ -183 +181 @@
         expr = expr->accept( exploder );
         if ( ! exploder.pass.foundUniqueExpr ) {
-                expr = new ast::CastExpr( expr->location, expr,
-                        new ast::ReferenceType( expr->result, ast::CV::Qualifiers() ) );
+                expr = new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } };
         }
         return expr;

src/Tuples/Explode.h

@@ -211 +211 @@
                         // Cast a reference away to a value-type to allow further explosion.
                         if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) {
-                                local = new ast::CastExpr( local->location, local, tupleType );
+                                local = new ast::CastExpr{ local, tupleType };
                         }
                         // Now we have to go across the tuple via indexing.

src/Tuples/TupleAssignment.cc

@@ -464 +464 @@
                                         // resolve ctor/dtor for the new object
                                         ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit( 
-                                                        InitTweak::genCtorInit( ret ), spotter.crntFinder.symtab );
+                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
                                         // remove environments from subexpressions of stmtExpr
                                         ast::Pass< EnvRemover > rm{ env };
@@ -550 +550 @@
                                         // is && and RHS is lvalue
                                         auto lhsType = lhsCand->expr->result.strict_as< ast::ReferenceType >();
-                                        rhsCand->expr = new ast::CastExpr{ 
-                                                rhsCand->expr->location, rhsCand->expr, lhsType->base };
+                                        rhsCand->expr = new ast::CastExpr{ rhsCand->expr, lhsType->base };
                                         ast::ptr< ast::ObjectDecl > lobj = newObject( lhsNamer, lhsCand->expr );
                                         ast::ptr< ast::ObjectDecl > robj = newObject( rhsNamer, rhsCand->expr );
@@ -604 +603 @@
                                         if ( ! lhsCand->expr.as< ast::CastExpr >() ) {
                                                 lhsCand->expr = new ast::CastExpr{ 
-                                                        lhsCand->expr->location, lhsCand->expr, 
-                                                        new ast::ReferenceType{ lhsCand->expr->result } };
+                                                        lhsCand->expr, new ast::ReferenceType{ lhsCand->expr->result } };
                                         }
 
@@ -616 +614 @@
                                                 if ( ! cand->expr->result.as< ast::ReferenceType >() ) {
                                                         cand->expr = new ast::CastExpr{
-                                                                cand->expr->location, cand->expr, 
-                                                                new ast::ReferenceType{ cand->expr->result } };
+                                                                cand->expr, new ast::ReferenceType{ cand->expr->result } };
                                                 }
                                         }