Changes in / [3ca540f:5da9d6a]

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/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.h (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• SymTab/Indexer.cc (modified) (1 diff)
• SymTab/Indexer.h (modified) (1 diff)
• 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)

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;
@@ -173 +172 @@
         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;
@@ -298 +296 @@
         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() );
+                }
         }
 
@@ -460 +469 @@
                 if ( isGenericType( memberExpr->aggregate->result ) ) {
                         // find the location of the member
-                        AggregateDecl * aggr = memberExpr->aggregate->result->getAggr();
+                        AggregateDecl * aggr = getAggr( memberExpr->aggregate->result );
                         std::list< Declaration * > & members = aggr->members;
                         memberIndex = std::distance( members.begin(), std::find( members.begin(), members.end(), memberExpr->member ) );
@@ -470 +479 @@
                 if ( memberIndex != -1 ) {
                         // using the location from the generic type, find the member in the instantiation and rebuild the member expression
-                        AggregateDecl * aggr = memberExpr->aggregate->result->getAggr();
+                        AggregateDecl * aggr = getAggr( memberExpr->aggregate->result );
                         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/ParseNode.h

@@ -408 +408 @@
 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
-                {
-                        $$ = new StatementNode( build_with( $3, $5 ) );
-                }
+                { throw SemanticError("With clause is currently unimplemented."); $$ = nullptr; } // FIX ME
         ;
 

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 ) {

src/ResolvExpr/AlternativeFinder.h

@@ -174 +174 @@
 
         Cost sumCost( const AltList &in );
-        void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 );
 
         template< typename InputIterator >
@@ -182 +181 @@
                 }
         }
-
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -74 +74 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
-                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -572 +571 @@
         }
 
-        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;
-                }
-        }
-
         template< typename T >
         bool isCharType( T t ) {

src/SymTab/Indexer.cc

@@ -567 +567 @@
         }
 
-        void Indexer::addWith( WithStmt * stmt ) {
-                for ( Expression * expr : stmt->exprs ) {
-                        if ( expr->result ) {
-                                AggregateDecl * aggr = expr->result->getAggr();
-                                assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
-
-                                // xxx - this is wrong, needs to somehow hook up chain of objects
-                                for ( Declaration * decl : aggr->members ) {
-                                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
-                                                addId( dwt );
-                                        }
-                                }
-                        }
-                }
-        }
-
         void Indexer::addIds( const std::list< DeclarationWithType * > & decls ) {
                 for ( auto d : decls ) {

src/SymTab/Indexer.h

@@ -76 +76 @@
                 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
                 void addIds( const std::list< DeclarationWithType * > & decls );

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 );
@@ -103 +101 @@
 
 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;
@@ -407 +405 @@
         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
@@ -440 +436 @@
 
         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( WithStmt * withStmt ) {
-        acceptAll( withStmt->exprs, *this );
-        maybeAccept( withStmt->stmt, *this );
-}
-
-void Visitor::visit( NullStmt * ) {
+void Visitor::visit( __attribute__((unused)) NullStmt *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 );