Changeset 65197c2

Timestamp:

Dec 5, 2017, 2:17:17 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc

Children:

971d9f2, a85e44c, c13e8dc8

Parents:

12d2dc8 (diff), 866f560 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• Common/PassVisitor.h (modified) (3 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Common/PassVisitor.proto.h (modified) (1 diff)
• GenPoly/InstantiateGeneric.cc (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (5 diffs)
• Parser/StatementNode.cc (modified) (1 diff)
• Parser/parser.yy (modified) (11 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (12 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• ResolvExpr/typeops.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (15 diffs)
• SymTab/Indexer.h (modified) (4 diffs)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/ReferenceToType.cc (modified) (2 diffs)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Statement.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• tests/.expect/declarationErrors.txt (modified) (2 diffs)
• tests/.expect/with-statement.txt (added)
• tests/with-statement.c (added)

src/CodeGen/CodeGenerator.cc

@@ -1012 +1012 @@
         }
 
+        void CodeGenerator::postvisit( WithStmt * with ) {
+                if ( ! genC ) {
+                        output << "with ( ";
+                        genCommaList( with->exprs.begin(), with->exprs.end() );
+                        output << " ) ";
+                }
+                with->stmt->accept( *visitor );
+        }
 
         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {

src/CodeGen/CodeGenerator.h

@@ -102 +102 @@
                 void postvisit( CatchStmt * );
                 void postvisit( WaitForStmt * );
+                void postvisit( WithStmt * );
                 void postvisit( WhileStmt * );
                 void postvisit( ForStmt * );

src/Common/PassVisitor.h

@@ -81 +81 @@
         virtual void visit( FinallyStmt * finallyStmt ) override final;
         virtual void visit( WaitForStmt * waitforStmt ) override final;
+        virtual void visit( WithStmt * withStmt ) override final;
         virtual void visit( NullStmt * nullStmt ) override final;
         virtual void visit( DeclStmt * declStmt ) override final;
@@ -172 +173 @@
         virtual Statement * mutate( FinallyStmt * finallyStmt ) override final;
         virtual Statement * mutate( WaitForStmt * waitforStmt ) override final;
+        virtual Statement * mutate( WithStmt * withStmt ) override final;
         virtual NullStmt * mutate( NullStmt * nullStmt ) override final;
         virtual Statement * mutate( DeclStmt * declStmt ) override final;
@@ -296 +298 @@
         void indexerAddUnionFwd ( UnionDecl           * node ) { indexer_impl_addUnionFwd ( pass, 0, node ); }
         void indexerAddTrait    ( TraitDecl           * node ) { indexer_impl_addTrait    ( pass, 0, node ); }
+        void indexerAddWith     ( WithStmt            * node ) { indexer_impl_addWith    ( pass, 0, node ); }
+
 
         template< typename TreeType, typename VisitorType >

src/Common/PassVisitor.impl.h

@@ -985 +985 @@
 }
 
+
+
+//--------------------------------------------------------------------------
+// NullStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( WithStmt * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->exprs, *this );
+        {
+                // catch statements introduce a level of scope (for the caught exception)
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                indexerAddWith( node );
+                maybeAccept_impl( node->stmt, *this );
+        }
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( WithStmt * node ) {
+        MUTATE_START( node );
+        maybeMutate_impl( node->exprs, *this );
+        {
+                // catch statements introduce a level of scope (for the caught exception)
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                indexerAddWith( node );
+                maybeMutate_impl( node->stmt, *this );
+        }
+        MUTATE_END( Statement, node );
+}
+
 //--------------------------------------------------------------------------
 // NullStmt

src/Common/PassVisitor.proto.h

@@ -208 +208 @@
 INDEXER_FUNC( addUnion  , UnionDecl *           );
 INDEXER_FUNC( addTrait  , TraitDecl *           );
+INDEXER_FUNC( addWith   , WithStmt *            );
 
 

src/GenPoly/InstantiateGeneric.cc

@@ -453 +453 @@
                         return false;
                 }
-
-                AggregateDecl * getAggr( Type * t ) {
-                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) {
-                                return inst->baseStruct;
-                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
-                                return inst->baseUnion;
-                        }
-                        assertf( false, "Non-aggregate type: %s", toString( t ).c_str() );
-                }
         }
 
@@ -469 +460 @@
                 if ( isGenericType( memberExpr->aggregate->result ) ) {
                         // find the location of the member
-                        AggregateDecl * aggr = getAggr( memberExpr->aggregate->result );
+                        AggregateDecl * aggr = memberExpr->aggregate->result->getAggr();
                         std::list< Declaration * > & members = aggr->members;
                         memberIndex = std::distance( members.begin(), std::find( members.begin(), members.end(), memberExpr->member ) );
@@ -479 +470 @@
                 if ( memberIndex != -1 ) {
                         // using the location from the generic type, find the member in the instantiation and rebuild the member expression
-                        AggregateDecl * aggr = getAggr( memberExpr->aggregate->result );
+                        AggregateDecl * aggr = memberExpr->aggregate->result->getAggr();
                         assertf( memberIndex < (int)aggr->members.size(), "Instantiation somehow has fewer members than the generic type." );
                         Declaration * member = *std::next( aggr->members.begin(), memberIndex );

src/Parser/DeclarationNode.cc

@@ -717 +717 @@
 }
 
-DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) {
+DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body, StatementNode * with ) {
         assert( type );
         assert( type->kind == TypeData::Function );
         assert( ! type->function.body );
+        if ( with ) {
+                // convert
+                //  void f(S s) with (s) { x = 0; }
+                // to
+                //  void f(S s) { with(s) { x = 0; } }
+                WithStmt * withStmt = strict_dynamic_cast< WithStmt * >( with->build() );
+                withStmt->stmt = body->build();
+                delete body;
+                delete with;
+                body = new StatementNode( new CompoundStmt( { withStmt } ) );
+        }
         type->function.body = body;
         return this;

src/Parser/ParseNode.h

@@ -69 +69 @@
 
         virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
-        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void printList( std::ostream &os, int indent = 0 ) const {
+                print( os, indent );
+                if ( next ) next->print( os, indent );
+        }
 
         static int indent_by;
@@ -120 +123 @@
         ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        virtual void print( std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {
+                os << expr.get() << std::endl;
+        }
         void printOneLine( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
 
@@ -257 +262 @@
         DeclarationNode * addBitfield( ExpressionNode * size );
         DeclarationNode * addVarArgs();
-        DeclarationNode * addFunctionBody( StatementNode * body );
+        DeclarationNode * addFunctionBody( StatementNode * body, StatementNode * with = nullptr );
         DeclarationNode * addOldDeclList( DeclarationNode * list );
         DeclarationNode * setBase( TypeData * newType );
@@ -359 +364 @@
         virtual StatementNode * append_last_case( StatementNode * );
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
-        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        virtual void print( std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {
+                os << stmt.get() << std::endl;
+        }
   private:
         std::unique_ptr<Statement> stmt;
@@ -408 +414 @@
 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
+WithStmt * build_with( ExpressionNode * exprs, StatementNode * stmt );
 
 //##############################################################################

src/Parser/StatementNode.cc

@@ -282 +282 @@
         node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
 
-        node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
+        node->orelse.statement  = maybeMoveBuild<Statement >( else_stmt );
         node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
 
         return node;
+}
+
+WithStmt * build_with( ExpressionNode * exprs, StatementNode * stmt ) {
+        std::list< Expression * > e;
+        buildMoveList( exprs, e );
+        Statement * s = maybeMoveBuild<Statement>( stmt );
+        return new WithStmt( e, s );
 }
 

src/Parser/parser.yy

@@ -1058 +1058 @@
 with_statement:
         WITH '(' tuple_expression_list ')' statement
-                { throw SemanticError("With clause is currently unimplemented."); $$ = nullptr; } // FIX ME
+                {
+                        $$ = new StatementNode( build_with( $3, $5 ) );
+                }
         ;
 
@@ -2410 +2412 @@
                 { $$ = nullptr; }
         | WITH '(' tuple_expression_list ')'
-                { throw SemanticError("With clause is currently unimplemented."); $$ = nullptr; } // FIX ME
+                { $$ = new StatementNode( build_with( $3, nullptr ) ); }
         ;
 
@@ -2420 +2422 @@
                         // Add the function body to the last identifier in the function definition list, i.e., foo3:
                         //   [const double] foo1(), foo2( int ), foo3( double ) { return 3.0; }
-                        $1->get_last()->addFunctionBody( $3 );
+                        $1->get_last()->addFunctionBody( $3, $2 );
                         $$ = $1;
                 }
@@ -2428 +2430 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $2->addFunctionBody( $4 )->addType( $1 );
+                        $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
@@ -2435 +2437 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $2->addFunctionBody( $4 )->addQualifiers( $1 );
+                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
@@ -2442 +2444 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $2->addFunctionBody( $4 )->addQualifiers( $1 );
+                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
@@ -2449 +2451 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $3->addFunctionBody( $5 )->addQualifiers( $2 )->addQualifiers( $1 );
+                        $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 );
                 }
 
@@ -2458 +2460 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5 )->addType( $1 );
+                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addType( $1 );
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
@@ -2465 +2467 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5 )->addQualifiers( $1 );
+                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
@@ -2472 +2474 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5 )->addQualifiers( $1 );
+                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
@@ -2479 +2481 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 );
+                        $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 );
                 }
         ;

src/ResolvExpr/AlternativeFinder.cc

@@ -83 +83 @@
         }
 
+        void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
+                Indenter indent = { Indenter::tabsize, indentAmt };
+                for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
+                        i->print( os, indent );
+                        os << std::endl;
+                }
+        }
+
         namespace {
-                void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) {
-                        Indenter indent = { Indenter::tabsize, indentAmt };
-                        for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
-                                i->print( os, indent );
-                                os << std::endl;
-                        }
-                }
-
                 void makeExprList( const AltList &in, std::list< Expression* > &out ) {
                         for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
@@ -469 +469 @@
                         std::cerr << std::endl;
                 )
-                std::list< DeclarationWithType* > candidates;
+                std::list< SymTab::Indexer::IdData > candidates;
                 decls.lookupId( curDecl->get_name(), candidates );
 ///   if ( candidates.empty() ) { std::cerr << "no candidates!" << std::endl; }
-                for ( std::list< DeclarationWithType* >::const_iterator candidate = candidates.begin(); candidate != candidates.end(); ++candidate ) {
+                for ( const auto & data : candidates ) {
+                        DeclarationWithType * candidate = data.id;
                         PRINT(
                                 std::cerr << "inferRecursive: candidate is ";
-                                (*candidate)->print( std::cerr );
+                                candidate->print( std::cerr );
                                 std::cerr << std::endl;
                         )
@@ -482 +483 @@
                         TypeEnvironment newEnv( newAlt.env );
                         OpenVarSet newOpenVars( openVars );
-                        Type *adjType = (*candidate)->get_type()->clone();
+                        Type *adjType = candidate->get_type()->clone();
                         adjustExprType( adjType, newEnv, indexer );
                         adjType->accept( global_renamer );
@@ -500 +501 @@
                                 Alternative newerAlt( newAlt );
                                 newerAlt.env = newEnv;
-                                assertf( (*candidate)->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( *candidate ).c_str() );
-                                DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
+                                assertf( candidate->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
 
                                 // everything with an empty idChain was pulled in by the current assertion.
@@ -516 +516 @@
                                 // DOESN'T WORK: grandchild nodes conflict with their cousins
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
-                                Expression *varExpr = new VariableExpr( candDecl );
+                                Expression *varExpr = data.combine();
                                 delete varExpr->get_result();
                                 varExpr->set_result( adjType->clone() );
@@ -522 +522 @@
                                         std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
                                         curDecl->print( std::cerr );
-                                        std::cerr << " with declaration " << (*candidate)->get_uniqueId() << " ";
-                                        (*candidate)->print( std::cerr );
+                                        std::cerr << " with declaration " << candidate->get_uniqueId() << " ";
+                                        candidate->print( std::cerr );
                                         std::cerr << std::endl;
                                 )
@@ -532 +532 @@
                                 }
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
-                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
                                 inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
                         } else {
@@ -1317 +1317 @@
 
         void AlternativeFinder::visit( NameExpr *nameExpr ) {
-                std::list< DeclarationWithType* > declList;
+                std::list< SymTab::Indexer::IdData > declList;
                 indexer.lookupId( nameExpr->get_name(), declList );
                 PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
-                for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
-                        VariableExpr newExpr( *i );
-                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
+                for ( auto & data : declList ) {
+                        Expression * newExpr = data.combine();
+                        // xxx - add in extra cost for with-statement exprs?
+                        alternatives.push_back( Alternative( newExpr, env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
-                                (*i)->print( std::cerr );
+                                data.id->print( std::cerr );
                                 std::cerr << std::endl;
                                 std::cerr << "newExpr is ";
-                                newExpr.print( std::cerr );
+                                newExpr->print( std::cerr );
                                 std::cerr << std::endl;
                         )
@@ -1420 +1421 @@
         }
 
-        void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
-                // assume no polymorphism
-                // assume no implicit conversions
-                assert( function->get_parameters().size() == 1 );
-                PRINT(
-                        std::cerr << "resolvAttr: funcDecl is ";
-                        funcDecl->print( std::cerr );
-                        std::cerr << " argType is ";
-                        argType->print( std::cerr );
-                        std::cerr << std::endl;
-                )
-                if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
-                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                                alternatives.back().expr->set_result( (*i)->get_type()->clone() );
-                        } // for
-                } // if
+        namespace {
+                void resolveAttr( SymTab::Indexer::IdData data, FunctionType *function, Type *argType, const TypeEnvironment &env, AlternativeFinder & finder ) {
+                        // assume no polymorphism
+                        // assume no implicit conversions
+                        assert( function->get_parameters().size() == 1 );
+                        PRINT(
+                                std::cerr << "resolvAttr: funcDecl is ";
+                                data.id->print( std::cerr );
+                                std::cerr << " argType is ";
+                                argType->print( std::cerr );
+                                std::cerr << std::endl;
+                        )
+                        const SymTab::Indexer & indexer = finder.get_indexer();
+                        AltList & alternatives = finder.get_alternatives();
+                        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
+                                alternatives.push_back( Alternative( new AttrExpr( data.combine(), argType->clone() ), env, Cost::zero ) );
+                                for ( DeclarationWithType * retVal : function->returnVals ) {
+                                        alternatives.back().expr->result = retVal->get_type()->clone();
+                                } // for
+                        } // if
+                }
         }
 
@@ -1443 +1448 @@
                 NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
                 assert( nameExpr );
-                std::list< DeclarationWithType* > attrList;
+                std::list< SymTab::Indexer::IdData > attrList;
                 indexer.lookupId( nameExpr->get_name(), attrList );
                 if ( attrExpr->get_isType() || attrExpr->get_expr() ) {
-                        for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
+                        for ( auto & data : attrList ) {
+                                DeclarationWithType * id = data.id;
                                 // check if the type is function
-                                if ( FunctionType *function = dynamic_cast< FunctionType* >( (*i)->get_type() ) ) {
+                                if ( FunctionType *function = dynamic_cast< FunctionType* >( id->get_type() ) ) {
                                         // assume exactly one parameter
                                         if ( function->get_parameters().size() == 1 ) {
                                                 if ( attrExpr->get_isType() ) {
-                                                        resolveAttr( *i, function, attrExpr->get_type(), env );
+                                                        resolveAttr( data, function, attrExpr->get_type(), env, *this );
                                                 } else {
                                                         AlternativeFinder finder( indexer, env );
@@ -1458 +1464 @@
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
                                                                 if ( choice->expr->get_result()->size() == 1 ) {
-                                                                        resolveAttr(*i, function, choice->expr->get_result(), choice->env );
+                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, *this );
                                                                 } // fi
                                                         } // for
@@ -1466 +1472 @@
                         } // for
                 } else {
-                        for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
-                                VariableExpr newExpr( *i );
-                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
+                        for ( auto & data : attrList ) {
+                                alternatives.push_back( Alternative( data.combine(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for

src/ResolvExpr/AlternativeFinder.h

@@ -142 +142 @@
                 template< typename OutputIterator >
                 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
-                void resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env );
 
                 const SymTab::Indexer &indexer;
@@ -151 +150 @@
 
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
-        void referenceToRvalueConversion( Expression *& expr );
 
         template< typename InputIterator, typename OutputIterator >
@@ -174 +172 @@
 
         Cost sumCost( const AltList &in );
+        void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 );
 
         template< typename InputIterator >
@@ -181 +180 @@
                 }
         }
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -26 +26 @@
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "CurrentObject.h"               // for CurrentObject
+#include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
 #include "RenameVars.h"                  // for RenameVars, global_renamer
@@ -40 +41 @@
 #include "SynTree/TypeSubstitution.h"    // for TypeSubstitution
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
+#include "Tuples/Tuples.h"
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
@@ -46 +48 @@
 
 namespace ResolvExpr {
-        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting {
+        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
                 Resolver() {}
                 Resolver( const SymTab::Indexer & other ) {
@@ -74 +76 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
+                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -571 +574 @@
         }
 
+        bool isStructOrUnion( Type * t ) {
+                t = t->stripReferences();
+                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
+
+        void Resolver::previsit( WithStmt * withStmt ) {
+                for ( Expression *& expr : withStmt->exprs )  {
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( expr );
+
+                        // only struct- and union-typed expressions are viable candidates
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( isStructOrUnion( alt.expr->result ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
+                                throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
+                                expr->print( stream );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                throw SemanticError( stream.str() );
+                        }
+
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & alt = winners.front();
+                        finishExpr( alt.expr, alt.env, expr->env );
+                        delete expr;
+                        expr = alt.expr;
+                        alt.expr = nullptr;
+
+                        // if with expression might be impure, create a temporary so that it is evaluated once
+                        if ( Tuples::maybeImpure( expr ) ) {
+                                static UniqueName tmpNamer( "_with_tmp_" );
+                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
+                                expr = new VariableExpr( tmp );
+                                stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
+                                if ( InitTweak::isConstructable( tmp->type ) ) {
+                                        // generate ctor/dtor and resolve them
+                                        tmp->init = InitTweak::genCtorInit( tmp );
+                                        tmp->accept( *visitor );
+                                }
+                        }
+                }
+        }
+
         template< typename T >
         bool isCharType( T t ) {

src/ResolvExpr/typeops.h

@@ -102 +102 @@
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
 
+        // in AlternativeFinder.cc
+        void referenceToRvalueConversion( Expression *& expr );
+
         // flatten tuple type into list of types
         template< typename OutputIterator >

src/SymTab/Indexer.cc

@@ -40 +40 @@
 
 namespace SymTab {
-        typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
+        std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
+                return out << "(" << data.id << "," << data.baseExpr << ")";
+        }
+
+        typedef std::unordered_map< std::string, Indexer::IdData > MangleTable;
         typedef std::unordered_map< std::string, MangleTable > IdTable;
         typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
@@ -97 +101 @@
         }
 
-        void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
+        void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const {
                 // only need to perform this step for constructors, destructors, and assignment functions
                 if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
@@ -104 +108 @@
                 struct ValueType {
                         struct DeclBall {
-                                FunctionDecl * decl;
+                                IdData decl;
                                 bool isUserDefinedFunc; // properties for this particular decl
                                 bool isDefaultCtor;
@@ -120 +124 @@
                         // another FunctionDecl for the current type was found - determine
                         // if it has special properties and update data structure accordingly
-                        ValueType & operator+=( FunctionDecl * function ) {
+                        ValueType & operator+=( IdData data ) {
+                                DeclarationWithType * function = data.id;
                                 bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() );
                                 bool isDefaultCtor = InitTweak::isDefaultConstructor( function );
                                 bool isDtor = InitTweak::isDestructor( function );
                                 bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() );
-                                decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
+                                decls.push_back( DeclBall{ data, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
                                 existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
                                 existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) );
@@ -135 +140 @@
                 }; // ValueType
 
-                std::list< DeclarationWithType * > copy;
+                std::list< IdData > copy;
                 copy.splice( copy.end(), out );
 
                 // organize discovered declarations by type
                 std::unordered_map< std::string, ValueType > funcMap;
-                for ( DeclarationWithType * decl : copy ) {
-                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
+                for ( auto decl : copy ) {
+                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
                                 std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
                                 assert( ! params.empty() );
@@ -147 +152 @@
                                 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
                                 assert( base );
-                                funcMap[ Mangler::mangle( base ) ] += function;
+                                funcMap[ Mangler::mangle( base ) ] += decl;
                         } else {
                                 out.push_back( decl );
@@ -164 +169 @@
                                 bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
                                 bool isUserDefinedFunc = ball.isUserDefinedFunc;
-                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
+                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
                                 bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
                                 bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
@@ -219 +224 @@
         }
 
-        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
+        void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
                 std::unordered_set< std::string > foundMangleNames;
 
@@ -289 +294 @@
                         const MangleTable &mangleTable = decls->second;
                         MangleTable::const_iterator decl = mangleTable.find( mangleName );
-                        if ( decl != mangleTable.end() ) return decl->second;
+                        if ( decl != mangleTable.end() ) return decl->second.id;
                 }
 
@@ -304 +309 @@
                         for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
                                 // check for C decls with the same name, skipping those with a compatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first != mangleName ) return true;
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first != mangleName ) return true;
                         }
                 }
@@ -321 +326 @@
                                 // check for C decls with the same name, skipping
                                 // those with an incompatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first == mangleName ) return true;
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first == mangleName ) return true;
                         }
                 }
@@ -403 +408 @@
         }
 
-        void Indexer::addId( DeclarationWithType *decl ) {
+        void Indexer::addId( DeclarationWithType *decl, Expression * baseExpr ) {
                 debugPrint( "Adding Id " << decl->name << std::endl );
                 makeWritable();
@@ -439 +444 @@
 
                 // add to indexer
-                tables->idTable[ name ][ mangleName ] = decl;
+                tables->idTable[ name ][ mangleName ] = { decl, baseExpr };
                 ++tables->size;
         }
@@ -563 +568 @@
                         if ( ! addedDeclConflicts( existing->second, decl ) ) {
                                 existing->second = decl;
+                        }
+                }
+        }
+
+        void Indexer::addWith( WithStmt * stmt ) {
+                for ( Expression * expr : stmt->exprs ) {
+                        if ( expr->result ) {
+                                AggregateDecl * aggr = expr->result->stripReferences()->getAggr();
+                                assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
+
+                                for ( Declaration * decl : aggr->members ) {
+                                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                                addId( dwt, expr );
+                                        }
+                                }
                         }
                 }
@@ -645 +665 @@
 
         }
+
+        Expression * Indexer::IdData::combine() const {
+                if ( baseExpr ) {
+                        Expression * base = baseExpr->clone();
+                        ResolvExpr::referenceToRvalueConversion( base );
+                        Expression * ret = new MemberExpr( id, base );
+                        // xxx - this introduces hidden environments, for now remove them.
+                        // std::swap( base->env, ret->env );
+                        delete base->env;
+                        base->env = nullptr;
+                        return ret;
+                } else {
+                        return new VariableExpr( id );
+                }
+        }
 } // namespace SymTab
 

src/SymTab/Indexer.h

@@ -39 +39 @@
                 void leaveScope();
 
+                struct IdData {
+                        DeclarationWithType * id;
+                        Expression * baseExpr; // WithExpr
+
+                        Expression * combine() const;
+                };
+
                 /// Gets all declarations with the given ID
-                void lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const;
+                void lookupId( const std::string &id, std::list< IdData > &out ) const;
                 /// Gets the top-most type declaration with the given ID
                 NamedTypeDecl *lookupType( const std::string &id ) const;
@@ -67 +74 @@
                 TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
 
-                void addId( DeclarationWithType *decl );
+                void addId( DeclarationWithType *decl, Expression * baseExpr = nullptr );
                 void addType( NamedTypeDecl *decl );
                 void addStruct( const std::string &id );
@@ -75 +82 @@
                 void addUnion( UnionDecl *decl );
                 void addTrait( TraitDecl *decl );
+
+                /// adds all of the IDs from WithStmt exprs
+                void addWith( WithStmt * );
 
                 /// convenience function for adding a list of Ids to the indexer
@@ -100 +110 @@
                 // so that they will not be selected
                 // void removeSpecialOverrides( FunctionDecl *decl );
-                void removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const;
+                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
 
                 /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)

src/SynTree/Mutator.cc

@@ -203 +203 @@
 }
 
+Statement * Mutator::mutate( WithStmt * withStmt ) {
+        mutateAll( withStmt->exprs, *this );
+        withStmt->stmt = maybeMutate( withStmt->stmt, *this );
+        return withStmt;
+}
+
 NullStmt * Mutator::mutate( NullStmt *nullStmt ) {
         return nullStmt;

src/SynTree/Mutator.h

@@ -50 +50 @@
         virtual Statement * mutate( FinallyStmt * catchStmt );
         virtual Statement * mutate( WaitForStmt * waitforStmt );
+        virtual Statement * mutate( WithStmt * withStmt );
         virtual NullStmt * mutate( NullStmt * nullStmt );
         virtual Statement * mutate( DeclStmt * declStmt );

src/SynTree/ReferenceToType.cc

@@ -70 +70 @@
 bool StructInstType::isComplete() const { return baseStruct ? baseStruct->has_body() : false; }
 
+AggregateDecl * StructInstType::getAggr() { return baseStruct; }
+
 void StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseStruct );
@@ -101 +103 @@
 
 bool UnionInstType::isComplete() const { return baseUnion ? baseUnion->has_body() : false; }
+
+AggregateDecl * UnionInstType::getAggr() { return baseUnion; }
 
 void UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {

src/SynTree/Statement.cc

@@ -456 +456 @@
 }
 
+
+WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Statement(), exprs( exprs ), stmt( stmt ) {}
+WithStmt::WithStmt( const WithStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
+        cloneAll( other.exprs, exprs );
+}
+WithStmt::~WithStmt() {
+        deleteAll( exprs );
+        delete stmt;
+}
+
+void WithStmt::print( std::ostream & os, Indenter indent ) const {
+        os << "With statement" << endl;
+        os << indent << "... with statement:" << endl << indent+1;
+        stmt->print( os, indent+1 );
+}
+
+
 NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
 }

src/SynTree/Statement.h

@@ -431 +431 @@
 };
 
+class WithStmt : public Statement {
+public:
+        std::list< Expression * > exprs;
+        Statement * stmt;
+
+        WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
+        WithStmt( const WithStmt & other );
+        virtual ~WithStmt();
+
+        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 
 // represents a declaration that occurs as part of a compound statement

src/SynTree/SynTree.h

@@ -55 +55 @@
 class FinallyStmt;
 class WaitForStmt;
+class WithStmt;
 class NullStmt;
 class DeclStmt;

src/SynTree/Type.h

@@ -178 +178 @@
         virtual bool isComplete() const { return true; }
 
+        virtual AggregateDecl * getAggr() {     assertf( false, "Non-aggregate type: %s", toString( this ).c_str() ); }
+
         virtual Type *clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
@@ -405 +407 @@
         virtual bool isComplete() const override;
 
+        virtual AggregateDecl * getAggr() override;
+
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
@@ -436 +440 @@
 
         virtual bool isComplete() const override;
+
+        virtual AggregateDecl * getAggr() override;
 
         /// looks up the members of this union named "name" and places them into "foundDecls"

src/SynTree/Visitor.cc

@@ -174 +174 @@
 }
 
-void Visitor::visit( __attribute__((unused)) NullStmt *nullStmt ) {
+void Visitor::visit( WithStmt * withStmt ) {
+        acceptAll( withStmt->exprs, *this );
+        maybeAccept( withStmt->stmt, *this );
+}
+
+void Visitor::visit( NullStmt * ) {
 }
 

src/SynTree/Visitor.h

@@ -52 +52 @@
         virtual void visit( FinallyStmt * finallyStmt );
         virtual void visit( WaitForStmt * waitforStmt );
+        virtual void visit( WithStmt * withStmt );
         virtual void visit( NullStmt * nullStmt );
         virtual void visit( DeclStmt * declStmt );

src/tests/.expect/declarationErrors.txt

@@ -7 +7 @@
 declarationErrors.c:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
   with members 
+    i: int 
    with body 
 
@@ -12 +13 @@
 declarationErrors.c:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
   with members 
+    i: int 
    with body