Report errors and warnings for hiding elements, issue 572.

corelib/src/implementation/promise_implementation.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Dart core library.
 
 class PromiseImpl<T> implements Promise<T> {
 
   // Enumeration of possible states:
   static final int CREATED = 0;
@@ skipping 303 matching lines @@
 
   Promise call(List message) {
     return _marshal(message, (List marshalled) {
       // TODO(kasperl): For now, the [Promise.then] implementation allows
       // me to return a promise and it will do the promise chaining.
       final result = new Promise();
       // The promise queue implementation guarantees that promise is
       // resolved at this point.
       SendPortImpl outgoing = _promise.value;
       ReceivePort incoming  = outgoing._callNow(marshalled);
-      incoming.receive((List message, replyTo) {
-        result.complete(message[0]);
+      incoming.receive((List receiveMessage, replyTo) {
+        result.complete(receiveMessage[0]);
       });
       return result;
     });
   }
 
   // Marshal the [message] and pass it to the [process] callback
   // function. Any promises are converted to a port which expects to
   // receive a port from the other side down which the remote promise
   // can be completed by sending the promise's completion value.
   Promise _marshal(List message, process(List marshalled)) {
@@ skipping 14 matching lines @@
           // This port will receive a SendPort that can be used to
           // signal completion of this promise to the corresponding
           // promise that the other end has created.
           ReceivePort receiveCompleter = new ReceivePort.singleShot();
           marshalled[i] = receiveCompleter.toSendPort();
           Promise<SendPort> completer = new Promise<SendPort>();
           receiveCompleter.receive((var msg, SendPort replyPort) {
             completer.complete(msg[0]);
           });
           entry.addCompleteHandler((value) {
-            completer.addCompleteHandler((SendPort port) {
-              _marshal([value], (List message) => port.send(message, null));
+            completer.addCompleteHandler((SendPort completePort) {
+              _marshal([value], (List completeMessage) => completePort.send(completeMessage, null));
             });
           });
         } else {
           // FIXME(kasperl, benl): this should probably be a copy?
           marshalled[i] = entry;
         }
         if (marshalled[i] is ReceivePort) {
           throw new Exception("Despite the documentation, you cannot send a ReceivePort");
         } 
       }
       return process(marshalled);
     }).flatten();
   }
 
   Promise<SendPort> _promise;
   static Map<SendPort, Dispatcher> _dispatchers;
 
 }