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

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
@@ -33 +32 @@
 #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
@@ -51 +49 @@
 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 ) {
@@ -99 +94 @@
                 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 );
         }
@@ -165 +158 @@
                                         castExpr->arg = nullptr;
                                         std::swap( expr->env, castExpr->env );
+                                        delete castExpr;
                                 }
                         }
@@ -171 +165 @@
 
         namespace {
-                void findUnfinishedKindExpression( Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
+                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) {
                         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, mode );
+                        finder.find( untyped, adjust, prune, failFast );
 
                         #if 0
@@ -216 +207 @@
                         Alternative & choice = winners.front();
                         if ( findDeletedExpr( choice.expr ) ) {
-                                trace( choice.expr );
-                                SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
+                                SemanticError( untyped->location, 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, ResolvMode mode = ResolvMode{}) {
+                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) {
                         if ( ! untyped ) return;
                         Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
+                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
                         finishExpr( choice.expr, choice.env, untyped->env );
+                        delete untyped;
                         untyped = choice.expr;
                         choice.expr = nullptr;
@@ -251 +241 @@
                 assertf( expr, "expected a non-null expression." );
 
-                auto untyped = new CastExpr{ expr }; // cast to void
+                static CastExpr untyped( nullptr ); // cast to void
+                untyped.location = expr->location;
 
                 // set up and resolve expression cast to void
+                untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
+                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
                 env = std::move( choice.env );
 
                 // clean up resolved expression
-                return castExpr->arg;
+                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;
         }
 
@@ -268 +265 @@
                 Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
                 finishExpr( newExpr, env, untyped->env );
+                delete untyped;
                 untyped = newExpr;
         }
@@ -277 +275 @@
         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 );
@@ -448 +449 @@
                                 castExpr->arg = nullptr;
                                 std::swap( newExpr->env, castExpr->env );
+                                delete castExpr;
                         }
                         caseStmt->condition = newExpr;
@@ -580 +582 @@
 
                                                         // Make sure we don't widen any existing bindings
-                                                        for ( auto & i : resultEnv ) {
-                                                                i.allowWidening = false;
-                                                        }
-
+                                                        resultEnv.forbidWidening();
+                                                        
                                                         // 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)
@@ -764 +765 @@
                                                         ce->set_arg( nullptr );
                                                         std::swap( ce->env, newExpr->env );
+                                                        delete ce;
                                                 }
                                         }
@@ -814 +816 @@
                 // could not find valid constructor, or found an intrinsic constructor
                 // fall back on C-style initializer
-                ctorInit->set_ctor( nullptr );
-                ctorInit->set_dtor( nullptr );
+                delete ctorInit->get_ctor();
+                ctorInit->set_ctor( NULL );
+                delete ctorInit->get_dtor();
+                ctorInit->set_dtor( NULL );
                 maybeAccept( ctorInit->get_init(), *visitor );
         }
@@ -841 +845 @@
 
                 // found a constructor - can get rid of C-style initializer
+                delete ctorInit->init;
                 ctorInit->init = nullptr;
 
@@ -847 +852 @@
                 // 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;
                 }