Changeset a556492

Timestamp:

Feb 17, 2022, 4:04:23 PM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

9ef9644

Parents:

7d7ef6f

Message:

There was less extra code in ForallPointerDecay? then I hopped, but it is gone now.

File:

• src/Validate/ForallPointerDecay.cpp (modified) (3 diffs)

src/Validate/ForallPointerDecay.cpp

@@ -82 +82 @@
                         (void)count;
 
+                        // Update the type (type substution does not seem to cover it).
                         if ( auto func = copy.as<ast::FunctionDecl>() ) {
                                 auto mut = ast::mutate( func );
@@ -118 +119 @@
         }
 
-        static AssertionList expandTrait_DR(
-                        const TypeDeclVec & typeDecls, const ast::TraitInstType * inst ) {
-                assertf( inst->base, "Trait instance not linked to base trait: %s",
-                        toCString( inst ) );
-                AssertionList assertions;
-                assertf( inst->params.size() == inst->base->params.size(),
-                        "Trait instance has incorrect number of params: %s",
-                        toCString( inst ) );
-                // Replace the TypeDecls that used to point to the trait.
-                ast::DeclReplacer::TypeMap typeMap;
-                for ( size_t i = 0 ; i < inst->params.size() ; ++i ) {
-                        typeMap[ inst->base->params[i].get() ] = typeDecls[i].get();
-                }
-                for ( const ast::ptr<ast::Decl> & decl : inst->base->members ) {
-                        auto copy = strict_dynamic_cast<const ast::DeclWithType *>(
-                                ast::DeclReplacer::replace(
-                                        ast::deepCopy( decl.get() ), typeMap ) );
-                        // TODO: Does DeclReplacer make this redundent?
-                        if ( auto func = dynamic_cast<const ast::FunctionDecl *>(copy) ) {
-                                auto mut = ast::mutate( func );
-                                mut->type = makeFuncType( func );
-                                copy = mut;
-                        }
-                        assertions.push_back( copy );
-                }
-                return assertions;
-        }
-
-        static AssertionList expandAssertions_DR(
-                        const TypeDeclVec & typeDecls, const AssertionList & assertions ) {
-                AssertionList newAsserts;
-                for ( const ast::ptr<ast::DeclWithType> & assert : assertions ) {
-                        if ( auto traitInst = dynamic_cast<const ast::TraitInstType *>(
-                                        assert->get_type() ) ) {
-                                auto moreAsserts = expandTrait_DR( typeDecls, traitInst );
-                                append( newAsserts, moreAsserts );
-                        } else {
-                                newAsserts.push_back( assert );
-                        }
-                }
-                return newAsserts;
-        }
-
-        // They had better all be unique for this to work.
-        static TypeDeclVec expandTypeDecls_DR( const TypeDeclVec & old ) {
-                TypeDeclVec typeDecls;
-                for ( const ast::TypeDecl * typeDecl : old ) {
-                        typeDecls.push_back( ast::mutate_field( typeDecl,
-                                &ast::TypeDecl::assertions,
-                                expandAssertions_DR( old, typeDecl->assertions ) ) );
-                }
-                return typeDecls;
-        }
-
         const ast::FunctionDecl * postvisit( const ast::FunctionDecl * decl ) {
                 if ( decl->assertions.empty() ) {
@@ -178 +125 @@
                 auto mut = ast::mutate( decl );
                 mut->assertions = expandAssertions( decl->assertions );
+                // Update the assertion list on the type as well.
                 auto mutType = ast::mutate( mut->type.get() );
-                // *
-                mutType->params.clear();
-                for ( auto & param : mut->params ) {
-                        mutType->params.emplace_back( param->get_type() );
-                }
-                mutType->returns.clear();
-                for ( auto & ret : mut->returns ) {
-                        mutType->returns.emplace_back( ret->get_type() );
-                }
-                mutType->forall.clear();
-                for ( auto & type_param : mut->type_params ) {
-                        mutType->forall.emplace_back(
-                                new ast::TypeInstType( type_param->name, type_param ) );
-                }
-                // * /
                 mutType->assertions.clear();
                 for ( auto & assertion : mut->assertions ) {