Changes in src/InitTweak/InitTweak.cc [c5f3c68:20eacb7]

File:

• src/InitTweak/InitTweak.cc (modified) (16 diffs)

src/InitTweak/InitTweak.cc

@@ -5 +5 @@
 #include <memory>                  // for __shared_ptr
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
@@ -13 +12 @@
 #include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
-#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SynTree/Attribute.h"     // for Attribute
@@ -20 +18 @@
 #include "SynTree/Expression.h"    // for Expression, UntypedExpr, Applicati...
 #include "SynTree/Initializer.h"   // for Initializer, ListInit, Designation
-#include "SynTree/Label.h"         // for Label
+#include "SynTree/Label.h"         // for Label, noLabels
 #include "SynTree/Statement.h"     // for CompoundStmt, ExprStmt, BranchStmt
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
@@ -30 +28 @@
 namespace InitTweak {
         namespace {
-                struct HasDesignations : public WithShortCircuiting {
+                class HasDesignations : public Visitor {
+                public:
                         bool hasDesignations = false;
-
-                        void previsit( BaseSyntaxNode * ) {
-                                // short circuit if we already know there are designations
-                                if ( hasDesignations ) visit_children = false;
-                        }
-
-                        void previsit( Designation * des ) {
-                                // short circuit if we already know there are designations
-                                if ( hasDesignations ) visit_children = false;
-                                else if ( ! des->get_designators().empty() ) {
-                                        hasDesignations = true;
-                                        visit_children = false;
-                                }
+                        virtual void visit( Designation * des ) {
+                                if ( ! des->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( des );
                         }
                 };
 
-                struct InitDepthChecker : public WithGuards {
+                class InitDepthChecker : public Visitor {
+                public:
                         bool depthOkay = true;
                         Type * type;
@@ -60 +50 @@
                                 maxDepth++;
                         }
-                        void previsit( ListInit * ) {
+                        virtual void visit( ListInit * listInit ) {
                                 curDepth++;
-                                GuardAction( [this]() { curDepth--; } );
                                 if ( curDepth > maxDepth ) depthOkay = false;
+                                Visitor::visit( listInit );
+                                curDepth--;
                         }
                 };
 
-                struct InitFlattener : public WithShortCircuiting {
-                        void previsit( SingleInit * singleInit ) {
-                                visit_children = false;
-                                argList.push_back( singleInit->value->clone() );
-                        }
+                class InitFlattener : public Visitor {
+                        public:
+                        virtual void visit( SingleInit * singleInit );
+                        virtual void visit( ListInit * listInit );
                         std::list< Expression * > argList;
                 };
 
+                void InitFlattener::visit( SingleInit * singleInit ) {
+                        argList.push_back( singleInit->get_value()->clone() );
+                }
+
+                void InitFlattener::visit( ListInit * listInit ) {
+                        // flatten nested list inits
+                        std::list<Initializer*>::iterator it = listInit->begin();
+                        for ( ; it != listInit->end(); ++it ) {
+                                (*it)->accept( *this );
+                        }
+                }
         }
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener> flattener;
+                InitFlattener flattener;
                 maybeAccept( init, flattener );
-                return flattener.pass.argList;
+                return flattener.argList;
         }
 
         bool isDesignated( Initializer * init ) {
-                PassVisitor<HasDesignations> finder;
+                HasDesignations finder;
                 maybeAccept( init, finder );
-                return finder.pass.hasDesignations;
+                return finder.hasDesignations;
         }
 
         bool checkInitDepth( ObjectDecl * objDecl ) {
-                PassVisitor<InitDepthChecker> checker( objDecl->type );
-                maybeAccept( objDecl->init, checker );
-                return checker.pass.depthOkay;
+                InitDepthChecker checker( objDecl->get_type() );
+                maybeAccept( objDecl->get_init(), checker );
+                return checker.depthOkay;
         }
 
         class InitExpander::ExpanderImpl {
         public:
-                virtual ~ExpanderImpl() = default;
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
                 virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ) = 0;
@@ -105 +105 @@
         public:
                 InitImpl( Initializer * init ) : init( init ) {}
-                virtual ~InitImpl() = default;
 
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
@@ -122 +121 @@
         public:
                 ExprImpl( Expression * expr ) : arg( expr ) {}
-                virtual ~ExprImpl() { delete arg; }
+
+                ~ExprImpl() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -193 +193 @@
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-                        *out++ = new IfStmt( cond, new ExprStmt( callExpr ), nullptr );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
 
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
                         increment->get_args().push_back( index->clone() );
-                        *out++ = new ExprStmt( increment );
+                        *out++ = new ExprStmt( noLabels, increment );
                 }
 
@@ -242 +242 @@
                                         std::list< Statement * > stmts;
                                         build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
-                                        stmts.push_back( new BranchStmt( switchLabel, BranchStmt::Break ) );
-                                        CaseStmt * caseStmt = new CaseStmt( condition, stmts );
+                                        stmts.push_back( new BranchStmt( noLabels, switchLabel, BranchStmt::Break ) );
+                                        CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
                                         branches.push_back( caseStmt );
                                 }
-                                *out++ = new SwitchStmt( index->clone(), branches );
-                                *out++ = new NullStmt( { switchLabel } );
+                                *out++ = new SwitchStmt( noLabels, index->clone(), branches );
+                                *out++ = new NullStmt( std::list<Label>{ switchLabel } );
                         }
                 }
@@ -260 +260 @@
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return nullptr;
-                CompoundStmt * block = new CompoundStmt();
+                CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
@@ -307 +307 @@
         }
 
-        struct CallFinder {
+        class CallFinder : public Visitor {
+        public:
+                typedef Visitor Parent;
                 CallFinder( const std::list< std::string > & names ) : names( names ) {}
 
-                void postvisit( ApplicationExpr * appExpr ) {
+                virtual void visit( ApplicationExpr * appExpr ) {
                         handleCallExpr( appExpr );
                 }
 
-                void postvisit( UntypedExpr * untypedExpr ) {
+                virtual void visit( UntypedExpr * untypedExpr ) {
                         handleCallExpr( untypedExpr );
                 }
@@ -324 +326 @@
                 template< typename CallExpr >
                 void handleCallExpr( CallExpr * expr ) {
+                        Parent::visit( expr );
                         std::string fname = getFunctionName( expr );
                         if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
@@ -332 +335 @@
 
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches ) {
-                static PassVisitor<CallFinder> finder( std::list< std::string >{ "?{}", "^?{}" } );
-                finder.pass.matches = &matches;
+                static CallFinder finder( std::list< std::string >{ "?{}", "^?{}" } );
+                finder.matches = &matches;
                 maybeAccept( stmt, finder );
         }
@@ -340 +343 @@
                 std::list< Expression * > matches;
                 collectCtorDtorCalls( stmt, matches );
-                assert( matches.size() <= 1 );
+                assertf( matches.size() <= 1, "%zd constructor/destructors found in %s", matches.size(), toString( stmt ).c_str() );
                 return matches.size() == 1 ? matches.front() : nullptr;
         }
@@ -520 +523 @@
         }
 
-        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
-                static FunctionDecl * assign = nullptr;
-                if ( ! assign ) {
-                        // temporary? Generate a fake assignment operator to represent bitwise assignments.
-                        // This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
-                        TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
-                        assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
-                }
-                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
-                        dst = new AddressExpr( dst );
-                } else {
-                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
-                }
-                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
-                        src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
-                }
-                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
-        }
-
-        struct ConstExprChecker : public WithShortCircuiting {
-                // most expressions are not const expr
-                void previsit( Expression * ) { isConstExpr = false; visit_children = false; }
-
-                void previsit( AddressExpr *addressExpr ) {
-                        visit_children = false;
-
+        class ConstExprChecker : public Visitor {
+        public:
+                ConstExprChecker() : isConstExpr( true ) {}
+
+                using Visitor::visit;
+
+                virtual void visit( ApplicationExpr * ) { isConstExpr = false; }
+                virtual void visit( UntypedExpr * ) { isConstExpr = false; }
+                virtual void visit( NameExpr * ) { isConstExpr = false; }
+                // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( AddressExpr *addressExpr ) {
                         // address of a variable or member expression is constexpr
                         Expression * arg = addressExpr->get_arg();
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
                 }
-
-                // these expressions may be const expr, depending on their children
-                void previsit( SizeofExpr * ) {}
-                void previsit( AlignofExpr * ) {}
-                void previsit( UntypedOffsetofExpr * ) {}
-                void previsit( OffsetofExpr * ) {}
-                void previsit( OffsetPackExpr * ) {}
-                void previsit( AttrExpr * ) {}
-                void previsit( CommaExpr * ) {}
-                void previsit( LogicalExpr * ) {}
-                void previsit( ConditionalExpr * ) {}
-                void previsit( CastExpr * ) {}
-                void previsit( ConstantExpr * ) {}
-
-                bool isConstExpr = true;
+                virtual void visit( UntypedMemberExpr * ) { isConstExpr = false; }
+                virtual void visit( MemberExpr * ) { isConstExpr = false; }
+                virtual void visit( VariableExpr * ) { isConstExpr = false; }
+                // these might be okay?
+                // virtual void visit( SizeofExpr *sizeofExpr );
+                // virtual void visit( AlignofExpr *alignofExpr );
+                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetPackExpr *offsetPackExpr );
+                // virtual void visit( AttrExpr *attrExpr );
+                // virtual void visit( CommaExpr *commaExpr );
+                // virtual void visit( LogicalExpr *logicalExpr );
+                // virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( TypeExpr * ) { isConstExpr = false; }
+                virtual void visit( AsmExpr * ) { isConstExpr = false; }
+                virtual void visit( UntypedValofExpr * ) { isConstExpr = false; }
+                virtual void visit( CompoundLiteralExpr * ) { isConstExpr = false; }
+                virtual void visit( UntypedTupleExpr * ) { isConstExpr = false; }
+                virtual void visit( TupleExpr * ) { isConstExpr = false; }
+                virtual void visit( TupleAssignExpr * ) { isConstExpr = false; }
+
+                bool isConstExpr;
         };
 
         bool isConstExpr( Expression * expr ) {
                 if ( expr ) {
-                        PassVisitor<ConstExprChecker> checker;
+                        ConstExprChecker checker;
                         expr->accept( checker );
-                        return checker.pass.isConstExpr;
+                        return checker.isConstExpr;
                 }
                 return true;
@@ -578 +573 @@
         bool isConstExpr( Initializer * init ) {
                 if ( init ) {
-                        PassVisitor<ConstExprChecker> checker;
+                        ConstExprChecker checker;
                         init->accept( checker );
-                        return checker.pass.isConstExpr;
+                        return checker.isConstExpr;
                 } // if
                 // for all intents and purposes, no initializer means const expr