Use metadata annotation @patch for patch classes

runtime/lib/isolate_patch.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.
 
 import "dart:collection" show HashMap;
 import "dart:_internal";
 
-patch class ReceivePort {
-  /* patch */ factory ReceivePort() = _ReceivePortImpl;
+@patch class ReceivePort {
+  /* @patch */ factory ReceivePort() = _ReceivePortImpl;
 
-  /* patch */ factory ReceivePort.fromRawReceivePort(RawReceivePort rawPort) =
+  /* @patch */ factory ReceivePort.fromRawReceivePort(RawReceivePort rawPort) =
       _ReceivePortImpl.fromRawReceivePort;
 }
 
-patch class Capability {
-  /* patch */ factory Capability() = _CapabilityImpl;
+@patch class Capability {
+  /* @patch */ factory Capability() = _CapabilityImpl;
 }
 
 class _CapabilityImpl implements Capability {
   factory _CapabilityImpl() native "CapabilityImpl_factory";
 
   bool operator==(var other) {
     return (other is _CapabilityImpl) && _equals(other);
   }
 
   int get hashCode {
     return _get_hashcode();
   }
 
   _equals(other) native "CapabilityImpl_equals";
   _get_hashcode() native "CapabilityImpl_get_hashcode";
 }
 
-patch class RawReceivePort {
+@patch class RawReceivePort {
   /**
    * Opens a long-lived port for receiving messages.
    *
    * A [RawReceivePort] is low level and does not work with [Zone]s. It
    * can not be paused. The data-handler must be set before the first
    * event is received.
    */
-  /* patch */ factory RawReceivePort([void handler(event)]) {
+  /* @patch */ factory RawReceivePort([void handler(event)]) {
     _RawReceivePortImpl result = new _RawReceivePortImpl();
     result.handler = handler;
     return result;
   }
 }
 
 class _ReceivePortImpl extends Stream implements ReceivePort {
   _ReceivePortImpl() : this.fromRawReceivePort(new RawReceivePort());
 
   _ReceivePortImpl.fromRawReceivePort(this._rawPort) {
@@ skipping 208 matching lines @@
         entryPoint();
       }
     } else {
       entryPoint(message);
     }
   };
   // Make sure the message handler is triggered.
   port.sendPort.send(null);
 }
 
-patch class Isolate {
+@patch class Isolate {
   static final _currentIsolate = _getCurrentIsolate();
   static final _rootUri = _getCurrentRootUri();
 
-  /* patch */ static Isolate get current => _currentIsolate;
+  /* @patch */ static Isolate get current => _currentIsolate;
 
-  /* patch */ static Future<Uri> get packageRoot {
+  /* @patch */ static Future<Uri> get packageRoot {
     var hook = VMLibraryHooks.packageRootUriFuture;
     if (hook == null) {
       throw new UnsupportedError("Isolate.packageRoot");
     }
     return hook();
   }
 
-  /* patch */ static Future<Uri> get packageConfig {
+  /* @patch */ static Future<Uri> get packageConfig {
     var hook = VMLibraryHooks.packageConfigUriFuture;
     if (hook == null) {
       throw new UnsupportedError("Isolate.packageConfig");
     }
     return hook();
   }
 
-  /* patch */ static Future<Uri> resolvePackageUri(Uri packageUri) {
+  /* @patch */ static Future<Uri> resolvePackageUri(Uri packageUri) {
     var hook = VMLibraryHooks.resolvePackageUriFuture;
     if (hook == null) {
       throw new UnsupportedError("Isolate.resolvePackageUri");
     }
     return hook(packageUri);
   }
 
   static bool _packageSupported() =>
       (VMLibraryHooks.packageRootUriFuture != null) &&
       (VMLibraryHooks.packageConfigUriFuture != null) &&
       (VMLibraryHooks.resolvePackageUriFuture != null);
 
-  /* patch */ static Future<Isolate> spawn(
+  /* @patch */ static Future<Isolate> spawn(
       void entryPoint(message), var message,
       {bool paused: false, bool errorsAreFatal,
        SendPort onExit, SendPort onError}) async {
     // `paused` isn't handled yet.
     RawReceivePort readyPort;
     try {
       // The VM will invoke [_startIsolate] with entryPoint as argument.
       readyPort = new RawReceivePort();
 
       // We do not inherit the package root or package config settings
@@ skipping 16 matching lines @@
                      packageRoot, packageConfig);
       return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
       return await new Future<Isolate>.error(e, st);
     }
   }
 
-  /* patch */ static Future<Isolate> spawnUri(
+  /* @patch */ static Future<Isolate> spawnUri(
       Uri uri, List<String> args, var message,
       {bool paused: false,
        SendPort onExit,
        SendPort onError,
        bool errorsAreFatal,
        bool checked,
        Map<String, String> environment,
        Uri packageRoot,
        Uri packageConfig,
        bool automaticPackageResolution: false}) async {
@@ skipping 117 matching lines @@
   static void _spawnUri(SendPort readyPort, String uri,
                         List<String> args, var message,
                         bool paused, SendPort onExit, SendPort onError,
                         bool errorsAreFatal, bool checked,
                         List environment,
                         String packageRoot, String packageConfig)
       native "Isolate_spawnUri";
 
   static void _sendOOB(port, msg) native "Isolate_sendOOB";
 
-  /* patch */ void _pause(Capability resumeCapability) {
+  /* @patch */ void _pause(Capability resumeCapability) {
     var msg = new List(4)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _PAUSE
         ..[2] = pauseCapability
         ..[3] = resumeCapability;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void resume(Capability resumeCapability) {
+  /* @patch */ void resume(Capability resumeCapability) {
     var msg = new List(4)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _RESUME
         ..[2] = pauseCapability
         ..[3] = resumeCapability;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void addOnExitListener(SendPort responsePort,
+  /* @patch */ void addOnExitListener(SendPort responsePort,
                                      {Object response}) {
     var msg = new List(4)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _ADD_EXIT
         ..[2] = responsePort
         ..[3] = response;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void removeOnExitListener(SendPort responsePort) {
+  /* @patch */ void removeOnExitListener(SendPort responsePort) {
     var msg = new List(3)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _DEL_EXIT
         ..[2] = responsePort;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void setErrorsFatal(bool errorsAreFatal) {
+  /* @patch */ void setErrorsFatal(bool errorsAreFatal) {
     var msg = new List(4)
       ..[0] = 0  // Make room for OOB message type.
       ..[1] = _ERROR_FATAL
       ..[2] = terminateCapability
       ..[3] = errorsAreFatal;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void kill({int priority: BEFORE_NEXT_EVENT}) {
+  /* @patch */ void kill({int priority: BEFORE_NEXT_EVENT}) {
     var msg = new List(4)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _KILL
         ..[2] = terminateCapability
         ..[3] = priority;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void ping(SendPort responsePort, {Object response,
+  /* @patch */ void ping(SendPort responsePort, {Object response,
                                                 int priority: IMMEDIATE}) {
     var msg = new List(5)
         ..[0] = 0  // Make room for OOM message type.
         ..[1] = _PING
         ..[2] = responsePort
         ..[3] = priority
         ..[4] = response;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void addErrorListener(SendPort port) {
+  /* @patch */ void addErrorListener(SendPort port) {
     var msg = new List(3)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _ADD_ERROR
         ..[2] = port;
     _sendOOB(controlPort, msg);
   }
 
-  /* patch */ void removeErrorListener(SendPort port) {
+  /* @patch */ void removeErrorListener(SendPort port) {
     var msg = new List(3)
         ..[0] = 0  // Make room for OOB message type.
         ..[1] = _DEL_ERROR
         ..[2] = port;
     _sendOOB(controlPort, msg);
   }
 
   static Isolate _getCurrentIsolate() {
     List portAndCapabilities = _getPortAndCapabilitiesOfCurrentIsolate();
     return new Isolate(portAndCapabilities[0],
                        pauseCapability: portAndCapabilities[1],
                        terminateCapability: portAndCapabilities[2]);
   }
 
   static List _getPortAndCapabilitiesOfCurrentIsolate()
       native "Isolate_getPortAndCapabilitiesOfCurrentIsolate";
 
   static Uri _getCurrentRootUri() {
     try {
       return Uri.parse(_getCurrentRootUriStr());
     } catch (e, s) {
       return null;
     }
   }
 
   static String _getCurrentRootUriStr()
       native "Isolate_getCurrentRootUriStr";
 }