Changes in src/Tuples/TupleAssignment.cc [5fb6830:03321e4]

File:

• src/Tuples/TupleAssignment.cc (modified) (9 diffs)

src/Tuples/TupleAssignment.cc

@@ -14 +14 @@
 //
 
-#include "ResolvExpr/AlternativeFinder.h"
-#include "ResolvExpr/Alternative.h"
-#include "ResolvExpr/typeops.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "Tuples.h"
-#include "Explode.h"
-#include "Common/SemanticError.h"
-#include "CodeGen/OperatorTable.h"
-#include "InitTweak/InitTweak.h"
-#include "InitTweak/GenInit.h"
-
-#include <functional>
-#include <algorithm>
-#include <iterator>
-#include <iostream>
-#include <cassert>
-#include <set>
-#include <unordered_set>
+#include <algorithm>                       // for transform
+#include <cassert>                         // for assert
+#include <iterator>                        // for back_insert_iterator, back...
+#include <list>                            // for _List_const_iterator, _Lis...
+#include <memory>                          // for unique_ptr, allocator_trai...
+#include <string>                          // for string
+
+#include "Common/UniqueName.h"             // for UniqueName
+#include "Common/utility.h"                // for zipWith
+#include "Explode.h"                       // for explode
+#include "InitTweak/GenInit.h"             // for genCtorInit
+#include "InitTweak/InitTweak.h"           // for getPointerBase, isAssignment
+#include "Parser/LinkageSpec.h"            // for Cforall
+#include "ResolvExpr/Alternative.h"        // for AltList, Alternative
+#include "ResolvExpr/AlternativeFinder.h"  // for AlternativeFinder, simpleC...
+#include "ResolvExpr/Cost.h"               // for Cost
+#include "ResolvExpr/Resolver.h"           // for resolveCtorInit
+#include "ResolvExpr/TypeEnvironment.h"    // for TypeEnvironment
+#include "SynTree/Declaration.h"           // for ObjectDecl
+#include "SynTree/Expression.h"            // for Expression, CastExpr, Name...
+#include "SynTree/Initializer.h"           // for ConstructorInit, SingleInit
+#include "SynTree/Statement.h"             // for ExprStmt
+#include "SynTree/Type.h"                  // for Type, Type::Qualifiers
+#include "SynTree/TypeSubstitution.h"      // for TypeSubstitution
+#include "SynTree/Visitor.h"               // for Visitor
 
 namespace Tuples {
@@ -78 +84 @@
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
-                return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
+                return dynamic_cast< TupleType * >( expr->get_result() );
         }
 
@@ -90 +96 @@
         }
 
-        bool refToTuple( Expression *expr ) {
-                assert( expr->get_result() );
+        bool pointsToTuple( Expression *expr ) {
                 // also check for function returning tuple of reference types
                 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                        return refToTuple( castExpr->get_arg() );
-                } else {
-                        return isTuple( expr );
+                        return pointsToTuple( castExpr->get_arg() );
+                } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) {
+                        return isTuple( addr->get_arg() );
                 }
                 return false;
@@ -111 +116 @@
         void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-                        if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
+                        if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
                                 fname = op->get_name();
                                 for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
                                         if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
-                                        if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) {
+                                        if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
                                                 // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
                                                 continue;
@@ -124 +129 @@
                                         const ResolvExpr::Alternative & alt1 = ali->front();
                                         auto begin = std::next(ali->begin(), 1), end = ali->end();
-                                        if ( refToTuple(alt1.expr) ) {
+                                        if ( pointsToTuple(alt1.expr) ) {
                                                 if ( isMultAssign( begin, end ) ) {
                                                         matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
@@ -182 +187 @@
 
                 ResolvExpr::Alternative lhsAlt = alts.front();
-                // explode is aware of casts - ensure every LHS expression is sent into explode with a reference cast
-                if ( ! dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
-                        lhsAlt.expr = new CastExpr( lhsAlt.expr, new ReferenceType( Type::Qualifiers(), lhsAlt.expr->get_result()->clone() ) );
+                // peel off the cast that exists on ctor/dtor expressions
+                bool isCast = false;
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
+                        lhsAlt.expr = castExpr->get_arg();
+                        castExpr->set_arg( nullptr );
+                        delete castExpr;
+                        isCast = true;
                 }
 
@@ -190 +199 @@
                 explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true );
 
-                for ( ResolvExpr::Alternative & alt : lhs ) {
-                        // every LHS value must be a reference - some come in with a cast expression, if it doesn't just cast to reference here.
-                        if ( ! dynamic_cast< ReferenceType * >( alt.expr->get_result() ) ) {
-                                alt.expr = new CastExpr( alt.expr, new ReferenceType( Type::Qualifiers(), alt.expr->get_result()->clone() ) );
+                // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
+                if ( isCast ) {
+                        for ( ResolvExpr::Alternative & alt : lhs ) {
+                                Expression *& expr = alt.expr;
+                                Type * castType = expr->get_result()->clone();
+                                Type * type = InitTweak::getPointerBase( castType );
+                                assert( type );
+                                type->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                                type->set_lvalue( true ); // xxx - might not need this
+                                expr = new CastExpr( expr, castType );
                         }
                 }
@@ -213 +228 @@
                 assert( left );
                 std::list< Expression * > args;
-                args.push_back( new VariableExpr( left ) );
+                args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) );
                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
                 if ( right ) args.push_back( new VariableExpr( right ) );
@@ -233 +248 @@
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
-                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
-                if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
-                        ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
-                        ret->set_init( ctorInit );
-                        ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
-                        EnvRemover rm; // remove environments from subexpressions of StmtExprs
-                        ctorInit->accept( rm );
-                }
+                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
+                ret->set_init( ctorInit );
+                ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
+                EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                ctorInit->accept( rm );
                 return ret;
         }