Changeset 65660bd for src/Tuples/TupleExpansion.cc

Timestamp:

Sep 22, 2016, 8:14:56 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

ac9ca96

Parents:

1132b62

git-author:

Rob Schluntz <rschlunt@…> (09/21/16 23:43:37)

git-committer:

Rob Schluntz <rschlunt@…> (09/22/16 08:14:56)

Message:

replace multiple-returning functions with tuple-returning functions, implement tuple ctor/dtor, allow N-arg tuple assignment

File:

• src/Tuples/TupleExpansion.cc (modified) (3 diffs)

src/Tuples/TupleExpansion.cc

@@ -49 +49 @@
 
                         virtual Type * mutate( TupleType * tupleType );
-                        virtual Type * mutate( FunctionType * ftype );
 
                         virtual CompoundStmt * mutate( CompoundStmt * stmt ) {
@@ -119 +118 @@
                 delete assnExpr;
                 return new StmtExpr( compoundStmt );
-        }
-
-        Type * TupleTypeReplacer::mutate( FunctionType * ftype ) {
-                // replace multiple-returning functions with functions which return a tuple
-                if ( ftype->get_returnVals().size() > 1 ) {
-                        TupleType * tupleType = safe_dynamic_cast<TupleType *>( ResolvExpr::extractResultType( ftype ) );
-                        ObjectDecl * retVal = new ObjectDecl( "__tuple_ret", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, tupleType, nullptr );
-                        // xxx - replace all uses of return vals with appropriate tuple index expr
-                        deleteAll( ftype->get_returnVals() );
-                        ftype->get_returnVals().clear();
-                        ftype->get_returnVals().push_back( retVal );
-                }
-                return Parent::mutate( ftype );
         }
 
@@ -167 +153 @@
         }
 
+        Expression * replaceTupleExpr( Type * result, const std::list< Expression * > & exprs ) {
+                if ( result->isVoid() ) {
+                        // void result - don't need to produce a value for cascading - just output a chain of comma exprs
+                        assert( ! exprs.empty() );
+                        std::list< Expression * >::const_iterator iter = exprs.begin();
+                        Expression * expr = *iter++;
+                        for ( ; iter != exprs.end(); ++iter ) {
+                                expr = new CommaExpr( expr, *iter );
+                        }
+                        return expr;
+                } else {
+                        // typed tuple expression - produce a compound literal which performs each of the expressions
+                        // as a distinct part of its initializer - the produced compound literal may be used as part of
+                        // another expression
+                        std::list< Initializer * > inits;
+                        for ( Expression * expr : exprs ) {
+                                inits.push_back( new SingleInit( expr ) );
+                        }
+                        return new CompoundLiteralExpr( result, new ListInit( inits ) );
+                }
+        }
+
         Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
-                assert( tupleExpr->get_result() );
-                std::list< Initializer * > inits;
-                for ( Expression * expr : tupleExpr->get_exprs() ) {
-                        inits.push_back( new SingleInit( expr ) );
-                }
-                return new CompoundLiteralExpr( tupleExpr->get_result(), new ListInit( inits ) );
-        }
-
-        TupleType * makeTupleType( const std::list< Expression * > & exprs ) {
+                Type * result = tupleExpr->get_result();
+                std::list< Expression * > exprs = tupleExpr->get_exprs();
+                assert( result );
+
+                tupleExpr->set_result( nullptr );
+                tupleExpr->get_exprs().clear();
+                delete tupleExpr;
+
+                return replaceTupleExpr( result, exprs );
+        }
+
+        Type * makeTupleType( const std::list< Expression * > & exprs ) {
+                // produce the TupleType which aggregates the types of the exprs
                 TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, false) );
                 Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
+                        if ( expr->get_result()->isVoid() ) {
+                                // if the type of any expr is void, the type of the entire tuple is void
+                                delete tupleType;
+                                return new VoidType( Type::Qualifiers() );
+                        }
                         Type * type = expr->get_result()->clone();
                         tupleType->get_types().push_back( type );
+                        // the qualifiers on the tuple type are the qualifiers that exist on all component types
                         qualifiers &= type->get_qualifiers();
                 } // for
                 return tupleType;
+        }
+
+        namespace {
+                /// determines if impurity (read: side-effects) may exist in a piece of code. Currently gives a very crude approximation, wherein any function call expression means the code may be impure
+                class ImpurityDetector : public Visitor {
+                public:
+                        typedef Visitor Parent;
+                        virtual void visit( ApplicationExpr * appExpr ) { maybeImpure = true;   }
+                        virtual void visit( UntypedExpr * untypedExpr ) { maybeImpure = true; }
+                        bool maybeImpure = false;
+                };
+        } // namespace
+
+        bool maybeImpure( Expression * expr ) {
+                ImpurityDetector detector;
+                expr->accept( detector );
+                return detector.maybeImpure;
         }
 } // namespace Tuples