Changeset c6b4432 for src/GenPoly/ScrubTyVars.h

Timestamp:

Nov 8, 2023, 2:01:11 PM (7 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

3e4bf0d, f5ec35a

Parents:

790d835

Message:

Remove BaseSyntaxNode? and clean-up.

File:

• src/GenPoly/ScrubTyVars.h (modified) (1 diff)

src/GenPoly/ScrubTyVars.h

@@ -19 +19 @@
 
 #include "AST/Fwd.hpp"        // for Node
-#include "Common/PassVisitor.h"
 #include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
-#include "SynTree/Mutator.h"  // for Mutator
-#include "SynTree/Type.h"     // for Type (ptr only), PointerType (ptr only)
-
-class AlignofExpr;
-class Expression;
-class SizeofExpr;
 
 namespace GenPoly {
-        struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards {
-                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
-                enum ScrubMode { FromMap, DynamicFromMap, All };
-
-                ScrubTyVars() : tyVars(nullptr), mode( All ) {}
-
-                ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {}
-
-        public:
-                /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
-
-                /// For all dynamic-layout types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars );
-
-                /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubAll( SynTreeClass *target );
-
-                /// determine if children should be visited based on whether base type should be scrubbed.
-                void primeBaseScrub( Type * );
-
-                void premutate( TypeInstType * ) { visit_children = false; }
-                void premutate( StructInstType * ) { visit_children = false; }
-                void premutate( UnionInstType * ) { visit_children = false; }
-                void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); }
-                void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); }
-                void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); }
-
-                Type * postmutate( TypeInstType * typeInst );
-                Type * postmutate( StructInstType * structInst );
-                Type * postmutate( UnionInstType * unionInst );
-                Expression * postmutate( SizeofExpr * szeof );
-                Expression * postmutate( AlignofExpr * algnof );
-                Type * postmutate( PointerType * pointer );
-
-          private:
-                /// Returns the type if it should be scrubbed, NULL otherwise.
-                Type* shouldScrub( Type *ty ) {
-                        switch ( mode ) {
-                        case FromMap: return isPolyType( ty, *tyVars );
-                        case DynamicFromMap: return isDynType( ty, *tyVars );
-                        case All: return isPolyType( ty );
-                        }
-                        assert(false); return nullptr; // unreachable
-                        // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
-                }
-
-                /// Mutates (possibly generic) aggregate types appropriately
-                Type* mutateAggregateType( Type *ty );
-
-                const TyVarMap *tyVars;  ///< Type variables to scrub
-                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
-
-                Type * dynType = nullptr; ///< result of shouldScrub
-        };
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
-                PassVisitor<ScrubTyVars> scrubber( tyVars );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
-                PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
-                PassVisitor<ScrubTyVars> scrubber;
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
 
 // ScrubMode and scrubTypeVarsBase are internal.