Changeset 8d182b1 for src/ResolvExpr/AdjustExprType.cc

Timestamp:

Nov 14, 2023, 12:19:09 PM (23 months ago)

Author:

caparson <caparson@…>

Branches:

master

Children:

1ccae59, 89a8bab

Parents:

df8ba61a (diff), 5625427 (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

File:

• src/ResolvExpr/AdjustExprType.cc (modified) (2 diffs)

src/ResolvExpr/AdjustExprType.cc

@@ -19 +19 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
-#include "SymTab/Indexer.h"       // for Indexer
-#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
-#include "SynTree/Mutator.h"      // for Mutator
-#include "SynTree/Type.h"         // for PointerType, TypeInstType, Type
-#include "TypeEnvironment.h"      // for EqvClass, TypeEnvironment
 
 namespace ResolvExpr {
 
 namespace {
-        class AdjustExprType_old final : public WithShortCircuiting {
-                public:
-                AdjustExprType_old( const TypeEnvironment & env, const SymTab::Indexer & indexer );
-                void premutate( VoidType * ) { visit_children = false; }
-                void premutate( BasicType * ) { visit_children = false; }
-                void premutate( PointerType * ) { visit_children = false; }
-                void premutate( ArrayType * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
-                void premutate( StructInstType * ) { visit_children = false; }
-                void premutate( UnionInstType * ) { visit_children = false; }
-                void premutate( EnumInstType * ) { visit_children = false; }
-                void premutate( TraitInstType * ) { visit_children = false; }
-                void premutate( TypeInstType * ) { visit_children = false; }
-                void premutate( TupleType * ) { visit_children = false; }
-                void premutate( VarArgsType * ) { visit_children = false; }
-                void premutate( ZeroType * ) { visit_children = false; }
-                void premutate( OneType * ) { visit_children = false; }
-
-                Type * postmutate( ArrayType * arrayType );
-                Type * postmutate( FunctionType * functionType );
-                Type * postmutate( TypeInstType * aggregateUseType );
-
-                private:
-                const TypeEnvironment & env;
-                const SymTab::Indexer & indexer;
-        };
-
-        AdjustExprType_old::AdjustExprType_old( const TypeEnvironment &env, const SymTab::Indexer &indexer )
-                : env( env ), indexer( indexer ) {
-        }
-
-        Type * AdjustExprType_old::postmutate( ArrayType * arrayType ) {
-                PointerType * pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
-                arrayType->base = nullptr;
-                delete arrayType;
-                return pointerType;
-        }
-
-        Type * AdjustExprType_old::postmutate( FunctionType * functionType ) {
-                return new PointerType{ Type::Qualifiers(), functionType };
-        }
-
-        Type * AdjustExprType_old::postmutate( TypeInstType * typeInst ) {
-                if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
-                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
-                                return new PointerType{ Type::Qualifiers(), typeInst };
-                        }
-                } else if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
-                        if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl * >( ntDecl ) ) {
-                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
-                                        return new PointerType{ Type::Qualifiers(), typeInst };
-                                } // if
-                        } // if
-                } // if
-                return typeInst;
-        }
-} // anonymous namespace
-
-void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-        PassVisitor<AdjustExprType_old> adjuster( env, indexer );
-        Type * newType = type->acceptMutator( adjuster );
-        type = newType;
-}
-
-void adjustExprType( Type *& type ) {
-        TypeEnvironment env;
-        SymTab::Indexer indexer;
-        adjustExprType( type, env, indexer );
-}
-
-namespace {
-        class AdjustExprType_new final : public ast::WithShortCircuiting {
+        class AdjustExprType final : public ast::WithShortCircuiting {
                 const ast::SymbolTable & symtab;
         public:
                 const ast::TypeEnvironment & tenv;
 
-                AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
+                AdjustExprType( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
                 : symtab( syms ), tenv( e ) {}
 
@@ -152 +75 @@
         const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
 ) {
-        ast::Pass<AdjustExprType_new> adjuster{ env, symtab };
+        ast::Pass<AdjustExprType> adjuster{ env, symtab };
         return type->accept( adjuster );
 }