Changes in src/ResolvExpr/Resolver.cc [2efe4b8:6f326b1]

File:

• src/ResolvExpr/Resolver.cc (modified) (21 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
@@ -60 +59 @@
                 void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
+                void previsit( StaticAssertDecl * assertDecl );
 
                 void previsit( ArrayType * at );
@@ -139 +139 @@
                                         castExpr->arg = nullptr;
                                         std::swap( expr->env, castExpr->env );
+                                        delete castExpr;
                                 }
                         }
@@ -147 +148 @@
                 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 );
@@ -177 +175 @@
                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
                         if ( winners.size() == 0 ) {
-                                SemanticError( untyped, toString( 
-                                        "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), 
-                                        "expression: ") );
+                                SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
                         } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for " 
-                                        << kindStr << (kindStr != "" ? " " : "") << "expression\n";
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
                                 untyped->print( stream );
                                 stream << " Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
-                                
                                 SemanticError( untyped->location, stream.str() );
                         }
@@ -194 +188 @@
                         Alternative & choice = winners.front();
                         if ( findDeletedExpr( choice.expr ) ) {
-                                trace( choice.expr );
-                                SemanticError( choice.expr, 
-                                        "Unique best alternative includes deleted identifier in " );
+                                SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
                         }
                         alt = std::move( choice );
-                        trace( alt );
                 }
 
@@ -208 +199 @@
                         findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
                         finishExpr( choice.expr, choice.env, untyped->env );
+                        delete untyped;
                         untyped = choice.expr;
                         choice.expr = nullptr;
@@ -230 +222 @@
                 assertf( expr, "expected a non-null expression." );
 
-                auto untyped = new CastExpr{ expr }; // cast to void
+                static CastExpr untyped( nullptr ); // 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, 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;
         }
 
@@ -247 +245 @@
                 Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
                 finishExpr( newExpr, env, untyped->env );
+                delete untyped;
                 untyped = newExpr;
         }
@@ -365 +364 @@
         }
 
+        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
+                findIntegralExpression( assertDecl->condition, indexer );
+        }
+
         void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
@@ -420 +423 @@
                         caseStmt->condition = castExpr->arg;
                         castExpr->arg = nullptr;
+                        delete castExpr;
                 }
         }
@@ -486 +490 @@
                                 ss << "' in call to waitfor";
                                 SemanticError( stmt->location, ss.str() );
+                        }
+
+                        if(clause.target.arguments.empty()) {
+                                SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");
                         }
 
@@ -536 +544 @@
                                                         OpenVarSet openVars;
                                                         AssertionSet resultNeed, resultHave;
-                                                        TypeEnvironment resultEnv;
+                                                        TypeEnvironment resultEnv( func.env );
+                                                        makeUnifiableVars( function, openVars, resultNeed );
+                                                        // add all type variables as open variables now so that those not used in the parameter
+                                                        // list are still considered open.
+                                                        resultEnv.add( function->forall );
 
                                                         // Load type variables from arguemnts into one shared space
@@ -552 +564 @@
                                                         auto param_end = function->parameters.end();
 
+                                                        int n_mutex_arg = 0;
+
                                                         // For every arguments of its set, check if it matches one of the parameter
                                                         // The order is important
@@ -560 +574 @@
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
-                                                                        SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
+                                                                        SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_arg, "\n" ));
                                                                 }
 
+                                                                n_mutex_arg++;
+
                                                                 // Check if the argument matches the parameter type in the current scope
-                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
+                                                                if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
                                                                         // Type doesn't match
                                                                         stringstream ss;
                                                                         ss << "candidate function not viable: no known convertion from '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "' to '";
                                                                         arg.expr->get_result()->print( ss );
-                                                                        ss << "' to '";
-                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "' with env '";
+                                                                        resultEnv.print(ss);
                                                                         ss << "'\n";
                                                                         SemanticError( function, ss.str() );
@@ -584 +602 @@
                                                                 // We ran out of arguments but still have parameters left
                                                                 // this function doesn't match
-                                                                SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
+                                                                SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_arg, "\n" ));
                                                         }
 
@@ -701 +719 @@
                 std::swap( initExpr->env, newExpr->env );
                 std::swap( initExpr->inferParams, newExpr->inferParams ) ;
+                delete initExpr;
 
                 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
@@ -718 +737 @@
                                                         ce->set_arg( nullptr );
                                                         std::swap( ce->env, newExpr->env );
+                                                        delete ce;
                                                 }
                                         }
@@ -768 +788 @@
                 // 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 );
         }
@@ -795 +817 @@
 
                 // found a constructor - can get rid of C-style initializer
+                delete ctorInit->init;
                 ctorInit->init = nullptr;
 
@@ -801 +824 @@
                 // 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;
                 }