Changeset b9f383f for src/ResolvExpr

Timestamp:

Apr 27, 2018, 2:35:00 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

5527759

Parents:

de6319f

Message:

named threads in thread tests
fixed bounded buffer expect
added error check for waitfor with no parameters
added missing parameters to bounded buffer EXT

File:

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

src/ResolvExpr/Resolver.cc

@@ -492 +492 @@
                         }
 
+                        if(clause.target.arguments.empty()) {
+                                SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");
+                        }
+
                         // Find all alternatives for all arguments in canonical form
                         std::vector< AlternativeFinder > argAlternatives;
@@ -556 +560 @@
                                                         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
@@ -564 +570 @@
                                                                         // 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 << "'\n";
                                                                         SemanticError( function, ss.str() );
@@ -588 +596 @@
                                                                 // 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" ));
                                                         }