Changes in src/Concurrency/Keywords.cc [42107b4:ceedde6]

File:

• src/Concurrency/Keywords.cc (modified) (8 diffs)

src/Concurrency/Keywords.cc

@@ -19 +19 @@
 #include <string>                  // for string, operator==
 
-#include "Common/GC.h"             // for new_static_root
 #include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/SemanticError.h"  // for SemanticError
@@ -192 +191 @@
                 void postvisit(   StructDecl * decl );
 
-                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
+                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
                 void validate( DeclarationWithType * );
                 void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
@@ -207 +206 @@
                 StructDecl* dtor_guard_decl = nullptr;
 
-                static Type* generic_func;
+                static std::unique_ptr< Type > generic_func;
         };
 
-        Type* MutexKeyword::generic_func = new_static_root<FunctionType>( noQualifiers, true );
+        std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
+                new FunctionType(
+                        noQualifiers,
+                        true
+                )
+        );
 
         //-----------------------------------------------------------------------------
@@ -284 +288 @@
                         // convert (thread &)t to (thread_desc &)*get_thread(t), etc.
                         if( !type_decl ) SemanticError( cast, context_error );
+                        Expression * arg = cast->arg;
+                        cast->arg = nullptr;
+                        delete cast;
                         return new CastExpr(
                                 UntypedExpr::createDeref(
-                                        new UntypedExpr( new NameExpr( getter_name ), { cast->arg } )
+                                        new UntypedExpr( new NameExpr( getter_name ), { arg } )
                                 ),
                                 new ReferenceType(
@@ -311 +318 @@
                 StructDecl * forward = decl->clone();
                 forward->set_body( false );
+                deleteAll( forward->get_members() );
                 forward->get_members().clear();
 
@@ -375 +383 @@
                 }
 
+                delete this_decl;
+
                 declsToAddBefore.push_back( forward );
                 if( needs_main ) declsToAddBefore.push_back( main_decl );
@@ -431 +441 @@
         void MutexKeyword::postvisit(FunctionDecl* decl) {
 
-                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
-                if( mutexArgs.empty() ) return;
-
-                if( CodeGen::isConstructor(decl->name) ) SemanticError( decl, "constructors cannot have mutex parameters" );
-
+                bool first = false;
+                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
                 bool isDtor = CodeGen::isDestructor( decl->name );
 
+                // Is this function relevant to monitors
+                if( mutexArgs.empty() ) {
+                        // If this is the destructor for a monitor it must be mutex
+                        if(isDtor) {
+                                Type* ty = decl->get_functionType()->get_parameters().front()->get_type();
+
+                                // If it's a copy, it's not a mutex
+                                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
+                                if( ! rty ) return;
+
+                                // If we are not pointing directly to a type, it's not a mutex
+                                Type* base = rty->get_base();
+                                if( dynamic_cast< ReferenceType * >( base ) ) return;
+                                if( dynamic_cast< PointerType * >( base ) ) return;
+
+                                // Check if its a struct
+                                StructInstType * baseStruct = dynamic_cast< StructInstType * >( base );
+                                if( !baseStruct ) return;
+
+                                // Check if its a monitor
+                                if(baseStruct->baseStruct->is_monitor() || baseStruct->baseStruct->is_thread())
+                                        SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters\n" );
+                        }
+                        return;
+                }
+
+                // Monitors can't be constructed with mutual exclusion
+                if( CodeGen::isConstructor(decl->name) && !first ) SemanticError( decl, "constructors cannot have mutex parameters" );
+
+                // It makes no sense to have multiple mutex parameters for the destructor
                 if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
 
+                // Make sure all the mutex arguments are monitors
                 for(auto arg : mutexArgs) {
                         validate( arg );
                 }
 
+                // Check if we need to instrument the body
                 CompoundStmt* body = decl->get_statements();
                 if( ! body ) return;
 
+                // Do we have the required headers
                 if( !monitor_decl || !guard_decl || !dtor_guard_decl )
-                        SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
-
+                        SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>\n" );
+
+                // Instrument the body
                 if( isDtor ) {
                         addDtorStatments( decl, body, mutexArgs );
@@ -474 +515 @@
         }
 
-        std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl ) {
+        std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl, bool & first ) {
                 std::list<DeclarationWithType*> mutexArgs;
 
+                bool once = true;
                 for( auto arg : decl->get_functionType()->get_parameters()) {
                         //Find mutex arguments
                         Type* ty = arg->get_type();
                         if( ! ty->get_mutex() ) continue;
+
+                        if(once) {first = true;}
+                        once = false;
 
                         //Append it to the list