Change to <- for types.

pkg/compiler/lib/src/helpers/trace.dart

 // Copyright (c) 2014, 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 '../common.dart';
 import '../util/util.dart';
 
-/// Function signature for [trace].
-typedef void Trace(String message,
-    {bool condition(String stackTrace), int limit, bool throwOnPrint});
-
 /**
  * Helper method for printing stack traces for debugging.
  *
  * [message] is printed as the header of the stack trace.
  *
  * If [condition] is provided, the stack trace is only printed if [condition]
  * returns [:true:] on the stack trace text. This can be used to filter the
  * printed stack traces based on their content. For instance only print stack
  * traces that contain specific paths.
  *
  * If [limit] is provided, the stack trace is limited to [limit] entries.
  *
  * If [throwOnPrint] is `true`, [message] will be thrown after the stack trace
  * has been printed. Together with [condition] this can be used to discover
  * unknown call-sites in tests by filtering known call-sites and throwning
  * otherwise.
  */
-Trace get trace {
+void <- (String message, {bool <- (String stackTrace) condition, int limit,
+    bool throwOnPrint})
+get trace {
   enableDebugMode();
   return _trace;
 }
 
 void _trace(String message,
-    {bool condition(String stackTrace), int limit, bool throwOnPrint: false}) {
+    {bool <- (String stackTrace) condition, int limit,
+    bool throwOnPrint: false}) {
   try {
     throw '';
   } catch (e, s) {
     String stackTrace;
     try {
       stackTrace = prettifyStackTrace(s,
           rangeStart: 1, rangeEnd: limit, filePrefix: stackTraceFilePrefix);
     } catch (e) {
       print(e);
       stackTrace = '$s';
     }
     if (condition != null) {
       if (!condition(stackTrace)) return;
     }
     print('$message\n$stackTrace');
     if (throwOnPrint) throw message;
   }
 }
 
 /// Creates a function to use as an `condition` argument in [trace] that filters
 /// stack traces that contains any of the [exceptions].
 traceExceptions(List<String> exceptions) {
   return (String stackTrace) => !exceptions.any(stackTrace.contains);
 }
 
 /// Function signature of [traceAndReport].
-typedef void TraceAndReport(
-    DiagnosticReporter reporter, Spannable node, String message,
-    {bool condition(String stackTrace), int limit, bool throwOnPrint});
+typedef TraceAndReport = void <- (
+    DiagnosticReporter, Spannable node, String message,
+    {bool <- (String stackTrace) condition, int limit, bool throwOnPrint})
+
 
 /// Calls [reportHere] and [trace] with the same message.
 TraceAndReport get traceAndReport {
   enableDebugMode();
   return _traceAndReport;
 }
 
 /// Calls [reportHere] and [trace] with the same message.
 TraceAndReport get reportAndTrace => traceAndReport;
 
 /// Implementation of [traceAndReport].
 void _traceAndReport(
     DiagnosticReporter reporter, Spannable node, String message,
-    {bool condition(String stackTrace), int limit, bool throwOnPrint: false}) {
+    {bool <- (String stackTrace) condition, int limit,
+    bool throwOnPrint: false}) {
   trace(message, limit: limit, throwOnPrint: throwOnPrint,
       condition: (String stackTrace) {
     bool result = condition != null ? condition(stackTrace) : true;
     if (result) {
       reportHere(reporter, node, message);
     }
     return result;
   });
 }
 
@@ skipping 250 matching lines @@
   }
   for (int index = text.length; index < intendedLength; index++) {
     int dotsIndex = index % dotsLength;
     sb.write(dots.substring(dotsIndex, dotsIndex + 1));
   }
   if (padLeft) {
     sb.write(text);
   }
   return sb.toString();
 }