Changeset 4c925cd for src/ResolvExpr/Resolver.cc

Timestamp:

Aug 14, 2020, 11:40:04 AM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

5715d43, fa5e0112

Parents:

309d814 (diff), badd22f (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/Resolver.cc (modified) (7 diffs)

src/ResolvExpr/Resolver.cc

@@ -982 +982 @@
                 ast::Pass<DeleteFinder_new> finder;
                 expr->accept( finder );
-                return finder.pass.delExpr;
+                return finder.core.delExpr;
         }
 
@@ -1072 +1072 @@
                 /// Strips extraneous casts out of an expression
                 struct StripCasts_new final {
-                        const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
+                        const ast::Expr * postvisit( const ast::CastExpr * castExpr ) {
                                 if (
-                                        castExpr->isGenerated
+                                        castExpr->isGenerated == ast::GeneratedCast
                                         && typesCompatible( castExpr->arg->result, castExpr->result )
                                 ) {
@@ -1128 +1128 @@
 
                 // set up and resolve expression cast to void
-                ast::CastExpr * untyped = new ast::CastExpr{ expr };
+                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
                 CandidateRef choice = findUnfinishedKindExpression(
                         untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
@@ -1236 +1236 @@
 
         public:
+                static size_t traceId;
                 Resolver_new() = default;
                 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
@@ -1266 +1267 @@
                 const ast::ConstructorInit * previsit( const ast::ConstructorInit * );
         };
-
-        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
-                ast::Pass< Resolver_new > resolver;
-                accept_all( translationUnit, resolver );
+        // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
+
+        void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) {
+                ast::Pass< Resolver_new >::run( translationUnit );
         }
 
@@ -1299 +1300 @@
                 // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
-                ast::ptr< ast::FunctionDecl > ret = functionDecl;
-                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
-                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
-
-                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
+                assert( functionDecl->unique() );
+                ast::FunctionType * mutType = mutate( functionDecl->type.get() );
+
+                for ( unsigned i = 0 ; i < mutType->params.size() ; ++i ) {
+                        if ( const ast::ObjectDecl * obj = mutType->params[i].as< ast::ObjectDecl >() ) {
                                 if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
                                         if ( init->value->env == nullptr ) continue;
                                         // clone initializer minus the initializer environment
-                                        ast::chain_mutate( ret )
-                                                ( &ast::FunctionDecl::type )
-                                                        ( &ast::FunctionType::params )[i]
-                                                                ( &ast::ObjectDecl::init )
-                                                                        ( &ast::SingleInit::value )->env = nullptr;
-
-                                        assert( functionDecl != ret.get() || functionDecl->unique() );
-                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
+                                        auto mutParam = mutate( mutType->params[i].strict_as< ast::ObjectDecl >() );
+                                        auto mutInit = mutate( mutParam->init.strict_as< ast::SingleInit >() );
+                                        auto mutValue = mutate( mutInit->value.get() );
+
+                                        mutValue->env = nullptr;
+                                        mutInit->value = mutValue;
+                                        mutParam->init = mutInit;
+                                        mutType->params[i] = mutParam;
+
+                                        assert( ! mutType->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env);
                                 }
                         }
                 }
-                return ret.get();
+                mutate_field(functionDecl, &ast::FunctionDecl::type, mutType);
+                return functionDecl;
         }
 
@@ -1341 +1345 @@
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
-                inEnumDecl = false;
+                inEnumDecl = true;
         }