Changeset ac9ca96

Timestamp:

Oct 13, 2016, 11:19:23 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:

7756647

Parents:

65660bd

Message:

consider tuples managed if a tuple constructor is declared, combine environments in tuple assignment

Location:

src

Files:

• InitTweak/GenInit.cc (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (2 diffs)

src/InitTweak/GenInit.cc

@@ -238 +238 @@
 
         bool CtorDtor::isManaged( Type * type ) const {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
+                        // tuple is also managed if any of its components are managed
+                        if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
+                                return true;
+                        }
+                }
                 return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
         }
@@ -245 +251 @@
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         type = at->get_base();
-                }
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
-                        return std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); });
                 }
                 return isManaged( type );

src/ResolvExpr/AlternativeFinder.cc

@@ -138 +138 @@
                 }
 
-                template< typename InputIterator >
-                void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
-                        while ( begin != end ) {
-                                result.simpleCombine( (*begin++).env );
-                        }
-                }
-
                 void renameTypes( Expression *expr ) {
                         expr->get_result()->accept( global_renamer );
@@ -216 +209 @@
         template< typename StructOrUnionType >
         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
-
-                // // member must be either a tuple expression or a name expr
-                // if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() ) ) {
-                //  addAggMembers( structInst, agg->expr, agg->cost, nameExpr->get_name() );
-                // } else {
-                //  TupleExpr * tupleExpr = safe_dynamic_cast< TupleExpr * >( memberExpr->get_member() );
-                //  // xxx - ...
-                //  assert( false );
-                // }
-                // if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( memberExpr->get_member() ) ) {
-
-                // }
-                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
-                const std::string & name = nameExpr->get_name();
-                std::list< Declaration* > members;
-                aggInst->lookup( name, members );
-                for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
-                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                                alternatives.push_back( Alternative( new MemberExpr( dwt, expr->clone() ), env, newCost ) );
-                                renameTypes( alternatives.back().expr );
-                        } else {
-                                assert( false );
-                        }
+                // member must be either a tuple expression or a name expr
+                if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
+                        const std::string & name = nameExpr->get_name();
+                        std::list< Declaration* > members;
+                        aggInst->lookup( name, members );
+                        for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
+                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
+                                        alternatives.push_back( Alternative( new MemberExpr( dwt, expr->clone() ), env, newCost ) );
+                                        renameTypes( alternatives.back().expr );
+                                } else {
+                                        assert( false );
+                                }
+                        }
+                } else if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( member ) ) {
+                        assert( false );
+                } else {
+                        // xxx - temporary
+                        std::cerr << member << std::endl;
+                        assertf( false, "reached unexpected case of addAggMembers" );
                 }
         }

src/ResolvExpr/AlternativeFinder.h

@@ -113 +113 @@
 
         Cost sumCost( const AltList &in );
+
+        template< typename InputIterator >
+        void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
+                while ( begin != end ) {
+                        result.simpleCombine( (*begin++).env );
+                }
+        }
 } // namespace ResolvExpr
 

src/Tuples/TupleAssignment.cc

@@ -142 +142 @@
                 for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
                         ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
-                        finder.findWithAdjustment(*i);
+                        try {
+                                finder.findWithAdjustment(*i);
+                        } catch (...) {
+                                return; // xxx - no match should not mean failure, it just means this particular tuple assignment isn't valid
+                        }
                         // prune expressions that don't coincide with
                         ResolvExpr::AltList alts = finder.get_alternatives();
@@ -157 +161 @@
                 }
                 // xxx - need to do this??
-                // TypeEnvironment compositeEnv;
-                // simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
-                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), currentFinder.get_environ(), ResolvExpr::sumCost( current ) ) );
+                ResolvExpr::TypeEnvironment compositeEnv;
+                simpleCombineEnvironments( current.begin(), current.end(), compositeEnv );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), compositeEnv, ResolvExpr::sumCost( current ) ) );
         }