Changes in src/GenPoly/Box.cc [eada3cf:e3e16bc]

File:

• src/GenPoly/Box.cc (modified) (24 diffs)

src/GenPoly/Box.cc

@@ -27 +27 @@
 
 #include "CodeGen/OperatorTable.h"
-#include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/ScopedMap.h"            // for ScopedMap, ScopedMap<>::iter...
 #include "Common/SemanticError.h"        // for SemanticError
@@ -158 +157 @@
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
-                class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
+                class PolyGenericCalculator final : public PolyMutator {
                 public:
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
+
                         PolyGenericCalculator();
 
-                        void premutate( ObjectDecl *objectDecl );
-                        void premutate( FunctionDecl *functionDecl );
-                        void premutate( TypedefDecl *objectDecl );
-                        void premutate( TypeDecl *objectDecl );
-                        Declaration * postmutate( TypeDecl *TraitDecl );
-                        void premutate( PointerType *pointerType );
-                        void premutate( FunctionType *funcType );
-                        void premutate( DeclStmt *declStmt );
-                        Expression *postmutate( MemberExpr *memberExpr );
-                        Expression *postmutate( SizeofExpr *sizeofExpr );
-                        Expression *postmutate( AlignofExpr *alignofExpr );
-                        Expression *postmutate( OffsetofExpr *offsetofExpr );
-                        Expression *postmutate( OffsetPackExpr *offsetPackExpr );
-
-                        void beginScope();
-                        void endScope();
+                        template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+                        virtual Statement *mutate( DeclStmt *declStmt ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                        virtual Expression *mutate( MemberExpr *memberExpr ) override;
+                        virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
+                        virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
+                        virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
+                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
+
+                        virtual void doBeginScope() override;
+                        virtual void doEndScope() override;
 
                 private:
@@ -191 +194 @@
                         /// Exits the type-variable scope
                         void endTypeScope();
-                        /// Enters a new scope for knowLayouts and knownOffsets and queues exit calls
-                        void beginGenericScope();
 
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
-                        TyVarMap scopeTyVars;
                 };
 
@@ -250 +250 @@
                 Pass1 pass1;
                 Pass2 pass2;
-                PassVisitor<PolyGenericCalculator> polyCalculator;
+                PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
 
@@ -256 +256 @@
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-                mutateAll( translationUnit, polyCalculator );
+                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
@@ -555 +555 @@
                 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                        return Mutator::mutate( typeDecl );
                 }
 
@@ -628 +628 @@
                                         } else {
                                                 // xxx - should this be an assertion?
-                                                throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr );
+                                                std::string x = env ? toString( *env ) : "missing env";
+                                                throw SemanticError( x + "\n" + "unbound type variable: " + tyParm->first + " in application ", appExpr );
                                         } // if
                                 } // if
@@ -705 +706 @@
                                 if ( concrete == 0 ) {
                                         return typeInst;
+                                        // xxx - should this be an assertion?
+//                                      std::string x = env ? toString( *env ) : "missing env";
+//                                      throw SemanticError( x + "\n" + "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
                                 } // if
                                 return concrete;
@@ -758 +762 @@
                                 } else if ( arg->get_result()->get_lvalue() ) {
                                         // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
-                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
-                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
-                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
-                                        //              return;
-                                        //      }
-                                        // }
                                         arg =  generalizedLvalue( new AddressExpr( arg ) );
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
@@ -1355 +1353 @@
                                 return handleDecl( typeDecl );
                         } else {
-                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
+                                return Parent::mutate( typeDecl );
                         }
                 }
@@ -1468 +1466 @@
 
                 PolyGenericCalculator::PolyGenericCalculator()
-                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
+                        : Parent(), knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
 
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
-                        GuardScope( scopeTyVars );
+                        scopeTyVars.beginScope();
                         makeTyVarMap( ty, scopeTyVars );
                 }
 
-                void PolyGenericCalculator::beginGenericScope() {
-                        GuardScope( *this );
-                }
-
-                void PolyGenericCalculator::premutate( ObjectDecl *objectDecl ) {
-                        beginTypeScope( objectDecl->get_type() );
-                }
-
-                void PolyGenericCalculator::premutate( FunctionDecl *functionDecl ) {
-                        beginGenericScope();
-
-                        beginTypeScope( functionDecl->get_functionType() );
-                }
-
-                void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
-                        beginTypeScope( typedefDecl->get_base() );
-                }
-
-                void PolyGenericCalculator::premutate( TypeDecl * typeDecl ) {
+                void PolyGenericCalculator::endTypeScope() {
+                        scopeTyVars.endScope();
+                }
+
+                template< typename DeclClass >
+                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
+                        beginTypeScope( type );
+                        // knownLayouts.beginScope();
+                        // knownOffsets.beginScope();
+
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
+
+                        // knownOffsets.endScope();
+                        // knownLayouts.endScope();
+                        endTypeScope();
+                        return ret;
+                }
+
+                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl, objectDecl->get_type() );
+                }
+
+                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
+
+                        DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
+                        knownOffsets.endScope();
+                        knownLayouts.endScope();
+                        return decl;
+                }
+
+                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                }
+
+                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                }
-
-                Declaration * PolyGenericCalculator::postmutate( TypeDecl *typeDecl ) {
-                        if ( Type * base = typeDecl->base ) {
-                                // add size/align variables for opaque type declarations
-                                TypeInstType inst( Type::Qualifiers(), typeDecl->name, typeDecl );
-                                std::string typeName = mangleType( &inst );
-                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-
-                                ObjectDecl * sizeDecl = ObjectDecl::newObject( sizeofName( typeName ), layoutType, new SingleInit( new SizeofExpr( base->clone() ) ) );
-                                ObjectDecl * alignDecl = ObjectDecl::newObject( alignofName( typeName ), layoutType->clone(), new SingleInit( new AlignofExpr( base->clone() ) ) );
-
-                                // ensure that the initializing sizeof/alignof exprs are properly mutated
-                                sizeDecl->acceptMutator( *visitor );
-                                alignDecl->acceptMutator( *visitor );
-
-                                // can't use makeVar, because it inserts into stmtsToAdd and TypeDecls can occur at global scope
-                                declsToAddAfter.push_back( alignDecl );
-                                // replace with sizeDecl
-                                return sizeDecl;
-                        }
-                        return typeDecl;
-                }
-
-                void PolyGenericCalculator::premutate( PointerType *pointerType ) {
+                        return Parent::mutate( typeDecl );
+                }
+
+                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
                         beginTypeScope( pointerType );
-                }
-
-                void PolyGenericCalculator::premutate( FunctionType *funcType ) {
+
+                        Type *ret = Parent::mutate( pointerType );
+
+                        endTypeScope();
+                        return ret;
+                }
+
+                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
                         beginTypeScope( funcType );
 
@@ -1534 +1534 @@
                                 }
                         }
-                }
-
-                void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
+
+                        Type *ret = Parent::mutate( funcType );
+
+                        endTypeScope();
+                        return ret;
+                }
+
+                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( findGeneric( objectDecl->get_type() ) ) {
@@ -1545 +1550 @@
                                                 new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
                                                 true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
-                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
+                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newBuf ) );
 
                                         delete objectDecl->get_init();
@@ -1551 +1556 @@
                                 }
                         }
+                        return Parent::mutate( declStmt );
                 }
 
@@ -1577 +1583 @@
                 }
 
-                Expression *PolyGenericCalculator::postmutate( MemberExpr *memberExpr ) {
+                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
+                        // mutate, exiting early if no longer MemberExpr
+                        Expression *expr = Parent::mutate( memberExpr );
+                        memberExpr = dynamic_cast< MemberExpr* >( expr );
+                        if ( ! memberExpr ) return expr;
+
                         // only mutate member expressions for polymorphic types
                         int tyDepth;
@@ -1624 +1635 @@
                 ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
                         ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
-                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
                 }
@@ -1703 +1714 @@
                                         addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
                                 }
 
@@ -1729 +1740 @@
                                 addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
 
                                 return true;
@@ -1737 +1748 @@
                 }
 
-                Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
+                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
                         Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
@@ -1747 +1758 @@
                 }
 
-                Expression *PolyGenericCalculator::postmutate( AlignofExpr *alignofExpr ) {
+                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
                         Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
@@ -1757 +1768 @@
                 }
 
-                Expression *PolyGenericCalculator::postmutate( OffsetofExpr *offsetofExpr ) {
+                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
+                        // mutate, exiting early if no longer OffsetofExpr
+                        Expression *expr = Parent::mutate( offsetofExpr );
+                        offsetofExpr = dynamic_cast< OffsetofExpr* >( expr );
+                        if ( ! offsetofExpr ) return expr;
+
                         // only mutate expressions for polymorphic structs/unions
                         Type *ty = offsetofExpr->get_type();
@@ -1777 +1793 @@
                 }
 
-                Expression *PolyGenericCalculator::postmutate( OffsetPackExpr *offsetPackExpr ) {
+                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
                         StructInstType *ty = offsetPackExpr->get_type();
 
@@ -1816 +1832 @@
                 }
 
-                void PolyGenericCalculator::beginScope() {
+                void PolyGenericCalculator::doBeginScope() {
                         knownLayouts.beginScope();
                         knownOffsets.beginScope();
                 }
 
-                void PolyGenericCalculator::endScope() {
+                void PolyGenericCalculator::doEndScope() {
                         knownLayouts.endScope();
                         knownOffsets.endScope();
@@ -1878 +1894 @@
 
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                        return Mutator::mutate( typeDecl );
                 }