Fix some warnings.

lib/isolate/frog/isolateimpl.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Concepts used here:
  *
  * "manager" - A manager contains one or more isolates, schedules their
  * execution, and performs other plumbing on their behalf.  The isolate
  * present at the creation of the manager is designated as its "root isolate".
@@ skipping 98 matching lines @@
 
   /** Reference to the main [_Manager].  Null in the main [_Manager] itself. */
   _ManagerStub mainManager;
 
   /** Registry of active [_ManagerStub]s.  Only used in the main [_Manager]. */
   Map<int, _ManagerStub> managers;
 
   _Manager() {
     _nativeDetectEnvironment();
     topEventLoop = new _EventLoop();
-    isolates = {};
-    managers = {};
+    isolates = new Map<int, _IsolateContext>();
+    managers = new Map<int, _ManagerStub>();
     if (isWorker) {  // "if we are not the main manager ourself" is the intent.
       mainManager = new _MainManagerStub();
       _nativeInitWorkerMessageHandler();
     }
   }
 
   void _nativeDetectEnvironment() native @"""
     this.isWorker = typeof ($globalThis['importScripts']) != 'undefined';
     this.fromCommandLine = typeof(window) == 'undefined';
     this.supportsWorkers = this.isWorker ||
@@ skipping 22 matching lines @@
   int id;
 
   /** Registry of receive ports currently active on this isolate. */
   Map<int, ReceivePort> ports;
 
   /** Holds isolate globals (statics and top-level properties). */
   var isolateStatics; // native object containing all globals of an isolate.
 
   _IsolateContext() {
     id = _globalState.nextIsolateId++;
-    ports = {};
+    ports = new Map<int, ReceivePort>();
     initGlobals();
   }
 
   // these are filled lazily the first time the isolate starts running.
   void initGlobals() native @'$initGlobals(this);';
 
   /**
    * Run [code] in the context of the isolate represented by [this]. Note this
    * is called from JavaScript (see $wrap_call in corejs.dart).
    */
   void eval(Function code) {
     var old = _globalState.currentContext;
     _globalState.currentContext = this;
     this._setGlobals();
     var result = null;
     try {
       result = code();
     } finally {
       _globalState.currentContext = old;
       if (old != null) old._setGlobals();
     }
     return result;
   }
 
   void _setGlobals() native @'$setGlobals(this);';
 
   /** Lookup a port registered for this isolate. */
-  ReceivePort lookup(int id) => ports[id];
+  ReceivePort lookup(int portId) => ports[portId];
 
   /** Register a port on this isolate. */
   void register(int portId, ReceivePort port)  {
     if (ports.containsKey(portId)) {
       throw new Exception("Registry: ports must be registered only once.");
     }
     ports[portId] = port;
     _globalState.isolates[id] = this; // indicate this isolate is active
   }
 
@@ skipping 113 matching lines @@
   void set id(int i);
   void set onmessage(Function f);
   void postMessage(msg);
   void terminate();
 }
 
 /** A stub for interacting with the main manager. */
 class _MainManagerStub implements _ManagerStub {
   get id() => 0;
   void set id(int i) { throw new NotImplementedException(); }
+  void set onmessage(f) {
+    throw new Exception("onmessage should not be set on MainManagerStub");
+  }
   void postMessage(msg) native @"$globalThis.postMessage(msg);";
   void terminate() {}  // Nothing useful to do here.
 }
 
 /**
  * A stub for interacting with a manager built on a web worker. The type
  * Worker is also defined in 'dart:dom', but we define it here to avoid
  * introducing a dependency from corelib to dom. This definition uses a
  * 'hidden' type (* prefix on the native name) to enforce that the type is
  * defined dynamically only when web workers are actually available.
  */
 class _WorkerStub implements _ManagerStub native "*Worker" {
   get id() native "return this.id;";
   void set id(i) native "this.id = i;";
   void set onmessage(f) native "this.onmessage = f;";
   void postMessage(msg) native "return this.postMessage(msg);";
   // terminate() is implemented by Worker.
+  abstract void terminate();
 }
 
 final String _SPAWNED_SIGNAL = "spawned";
 
 class _IsolateNatives {
 
   /** JavaScript-specific implementation to spawn an isolate. */
   static Future<SendPort> spawn(Isolate isolate, bool isLight) {
     Completer<SendPort> completer = new Completer<SendPort>();
     ReceivePort port = new ReceivePort();
@@ skipping 149 matching lines @@
   }
 
   /** Log a message, forwarding to the main [_Manager] if appropriate. */
   static _log(msg) {
     if (_globalState.isWorker) {
       _globalState.mainManager.postMessage(
           _serializeMessage({'command': 'log', 'msg': msg }));
     } else {
       try {
         _consoleLog(msg);
-      } catch(e, trace) {
+      } catch(var e, var trace) {
         throw new Exception(trace);
       }
     }
   }
 
   static void _consoleLog(msg) native "\$globalThis.console.log(msg);";
 
 
   /**
    * Extract the constructor of runnable, so it can be allocated in another
    * isolate.
    */
-  static var _getJSConstructor(Isolate runnable) native """
+  static Dynamic _getJSConstructor(Isolate runnable) native """
     return runnable.constructor;
   """;
 
   /** Extract the constructor name of a runnable */
   // TODO(sigmund): find a browser-generic way to support this.
-  static var _getJSConstructorName(Isolate runnable) native """
+  static Dynamic _getJSConstructorName(Isolate runnable) native """
     return runnable.constructor.name;
   """;
 
   /** Find a constructor given its name. */
-  static var _getJSConstructorFromName(String factoryName) native """
+  static Dynamic _getJSConstructorFromName(String factoryName) native """
     return \$globalThis[factoryName];
   """;
 
-  static var _getJSFunctionFromName(String functionName) native """
+  static Dynamic _getJSFunctionFromName(String functionName) native """
     return \$globalThis[functionName];
   """;
 
   /**
    * Get a string name for the function, if possible.  The result for
    * anonymous functions is browser-dependent -- it may be "" or "anonymous"
    * but you should probably not count on this.
    */
   static String _getJSFunctionName(Function f)
     // Comments on the code, outside of the string so they won't bulk up
@@ skipping 13 matching lines @@
     // in discussion on the CL, 9416119.
     native @"""
     if (typeof(f.name) === 'undefined') {
       return (f.toString().match(/function (.+)\(/) || [, (void 0)])[1];
     } else {
       return f.name || (void 0);
     }
   """;
 
   /** Create a new JavaScript object instance given its constructor. */
-  static var _allocate(var ctor) native "return new ctor();";
+  static Dynamic _allocate(var ctor) native "return new ctor();";
 
   /** Starts a non-worker isolate. */
   static SendPort _startNonWorker(Isolate runnable, SendPort replyTo) {
     // Spawn a new isolate and create the receive port in it.
     final spawned = new _IsolateContext();
 
     // Instead of just running the provided runnable, we create a
     // new cloned instance of it with a fresh state in the spawned
     // isolate. This way, we do not get cross-isolate references
     // through the runnable.
@@ skipping 87 matching lines @@
       'command': 'start2',
       'id': workerId,
       // Note: we serialize replyPort twice because the child worker needs to
       // first deserialize the worker id, before it can correctly deserialize
       // the port (port deserialization is sensitive to what is the current
       // workerId).
       'replyTo': _serializeMessage(replyPort),
       'functionName': functionName }));
   }
 }