Changes in src/ResolvExpr/Resolver.cc [d286cf68:b60f9d9]

File:

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

src/ResolvExpr/Resolver.cc

@@ -22 +22 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
+#include "Common/GC.h"                   // for new_generation, collect_young
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
@@ -32 +33 @@
 #include "ResolveTypeof.h"               // for resolveTypeof
 #include "Resolver.h"
+#include "ResolvMode.h"                  // for ResolvMode
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
@@ -49 +51 @@
 namespace ResolvExpr {
         struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
+        
+        friend void resolve( std::list<Declaration*> );
+
                 Resolver() {}
                 Resolver( const SymTab::Indexer & other ) {
@@ -94 +99 @@
                 CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
+                bool atTopLevel = false;  ///< Was this resolver set up at the top level of resolution
         };
 
         void resolve( std::list< Declaration * > translationUnit ) {
                 PassVisitor<Resolver> resolver;
+                resolver.pass.atTopLevel = true;  // mark resolver as top-level
                 acceptAll( translationUnit, resolver );
         }
@@ -158 +165 @@
                                         castExpr->arg = nullptr;
                                         std::swap( expr->env, castExpr->env );
-                                        delete castExpr;
                                 }
                         }
@@ -165 +171 @@
 
         namespace {
-                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
+                void findUnfinishedKindExpression( Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
                         assertf( untyped, "expected a non-null expression." );
+
+                        auto guard = new_generation();  // set up GC generation for this top-level expression
+
                         TypeEnvironment env;
                         AlternativeFinder finder( indexer, env );
-                        finder.find( untyped, adjust, prune, failFast );
+                        finder.find( untyped, mode );
 
                         #if 0
@@ -207 +216 @@
                         Alternative & choice = winners.front();
                         if ( findDeletedExpr( choice.expr ) ) {
-                                SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
+                                trace( choice.expr );
+                                SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
                         }
                         alt = std::move( choice );
+                        trace( alt );
                 }
 
                 /// resolve `untyped` to the expression whose alternative satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
-                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
                         if ( ! untyped ) return;
                         Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
+                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
                         finishExpr( choice.expr, choice.env, untyped->env );
-                        delete untyped;
                         untyped = choice.expr;
                         choice.expr = nullptr;
@@ -241 +251 @@
                 assertf( expr, "expected a non-null expression." );
 
-                static CastExpr untyped( nullptr ); // cast to void
-                untyped.location = expr->location;
+                auto untyped = new CastExpr{ expr }; // cast to void
 
                 // set up and resolve expression cast to void
-                untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
+                findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
                 env = std::move( choice.env );
 
                 // clean up resolved expression
-                Expression * ret = castExpr->arg;
-                castExpr->arg = nullptr;
-
-                // unlink the arg so that it isn't deleted twice at the end of the program
-                untyped.arg = nullptr;
-                return ret;
+                return castExpr->arg;
         }
 
@@ -265 +268 @@
                 Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
                 finishExpr( newExpr, env, untyped->env );
-                delete untyped;
                 untyped = newExpr;
         }
@@ -275 +277 @@
         void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
                 assert( untyped && type );
-                // transfer location to generated cast for error purposes
-                CodeLocation location = untyped->location;
                 untyped = new CastExpr( untyped, type );
-                untyped->location = location;
                 findSingleExpression( untyped, indexer );
                 removeExtraneousCast( untyped, indexer );
@@ -449 +448 @@
                                 castExpr->arg = nullptr;
                                 std::swap( newExpr->env, castExpr->env );
-                                delete castExpr;
                         }
                         caseStmt->condition = newExpr;
@@ -582 +580 @@
 
                                                         // Make sure we don't widen any existing bindings
-                                                        resultEnv.forbidWidening();
-                                                        
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
+
                                                         // Find any unbound type variables
                                                         resultEnv.extractOpenVars( openVars );
@@ -747 +747 @@
                 // and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
                 newExpr->spliceInferParams( initExpr );
-                delete initExpr;
 
                 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
@@ -765 +764 @@
                                                         ce->set_arg( nullptr );
                                                         std::swap( ce->env, newExpr->env );
-                                                        delete ce;
                                                 }
                                         }
@@ -816 +814 @@
                 // could not find valid constructor, or found an intrinsic constructor
                 // fall back on C-style initializer
-                delete ctorInit->get_ctor();
-                ctorInit->set_ctor( NULL );
-                delete ctorInit->get_dtor();
-                ctorInit->set_dtor( NULL );
+                ctorInit->set_ctor( nullptr );
+                ctorInit->set_dtor( nullptr );
                 maybeAccept( ctorInit->get_init(), *visitor );
         }
@@ -845 +841 @@
 
                 // found a constructor - can get rid of C-style initializer
-                delete ctorInit->init;
                 ctorInit->init = nullptr;
 
@@ -852 +847 @@
                 // to clean up generated code.
                 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
-                        delete ctorInit->ctor;
                         ctorInit->ctor = nullptr;
                 }
 
                 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
-                        delete ctorInit->dtor;
                         ctorInit->dtor = nullptr;
                 }