Changes in src/ResolvExpr/Resolver.cc [73973b6:30901270]

File:

• src/ResolvExpr/Resolver.cc (modified) (5 diffs)

src/ResolvExpr/Resolver.cc

@@ -1074 +1074 @@
                         const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
                                 if (
-                                        castExpr->isGenerated == ast::GeneratedCast
+                                        castExpr->isGenerated
                                         && typesCompatible( castExpr->arg->result, castExpr->result )
                                 ) {
@@ -1128 +1128 @@
 
                 // set up and resolve expression cast to void
-                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
+                ast::CastExpr * untyped = new ast::CastExpr{ expr };
                 CandidateRef choice = findUnfinishedKindExpression(
                         untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
@@ -1267 +1267 @@
         };
 
-        void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) {
+        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
                 ast::Pass< Resolver_new > resolver;
                 accept_all( translationUnit, resolver );
@@ -1299 +1299 @@
                 // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
-
-                // ast::ptr< ast::FunctionDecl > ret = functionDecl; 
-                // assert(functionDecl->type->unique());
-                assert(functionDecl->unique());
-                
-                auto mutType = mutate(functionDecl->type.get());
-
-                for ( unsigned i = 0; i < mutType->params.size(); ++i ) {
-                        const ast::ptr< ast::DeclWithType > & d = mutType->params[i];
-            if ( const ast::ObjectDecl * obj = d.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::FunctionDecl * mutDecl = mutate( functionDecl );
-                    // auto mutType = mutate( mutDecl->type.get() );
-                    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() );
-                    //ast::chain_mutate( ret )
-                    //  ( &ast::FunctionDecl::type )
-                    //      ( &ast::FunctionType::params )[i]
-                    //          ( &ast::ObjectDecl::init )
-                    //              ( &ast::SingleInit::value )->env = nullptr;
-                    // assert( functionDecl != mutDecl || functionDecl->unique() );
-                    mutValue->env = nullptr;
-                    mutInit->value = mutValue;
-                    mutParam->init = mutInit;
-                    mutType->params[i] = mutParam;
-                    // mutDecl->type = mutType;
-                    // functionDecl = mutDecl;
-                    assert( ! mutType->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env);
-                }
-            }
-                }
-                mutate_field(functionDecl, &ast::FunctionDecl::type, mutType);
-                return functionDecl;
+                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 >() ) {
+                                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 );
+                                }
+                        }
+                }
+                return ret.get();
         }
 
@@ -1357 +1341 @@
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
-                inEnumDecl = true;
+                inEnumDecl = false;
         }