Don't put spaces around magic generic method annotation comments.

lib/src/chunk_builder.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.
 
 library dart_style.src.chunk_builder;
 
 import 'chunk.dart';
 import 'dart_formatter.dart';
 import 'debug.dart' as debug;
 import 'line_writer.dart';
 import 'nesting_level.dart';
 import 'nesting_builder.dart';
 import 'rule/rule.dart';
 import 'source_code.dart';
 import 'whitespace.dart';
 
+/// Matches if the last character of a string is an identifier character.
+final _trailingIdentifierChar = new RegExp(r"[a-zA-Z0-9_]$");
+
 /// Takes the incremental serialized output of [SourceVisitor]--the source text
 /// along with any comments and preserved whitespace--and produces a coherent
 /// tree of [Chunk]s which can then be split into physical lines.
 ///
 /// Keeps track of leading indentation, expression nesting, and all of the hairy
 /// code required to seamlessly integrate existing comments into the pure
 /// output produced by [SourceVisitor].
 class ChunkBuilder {
   final DartFormatter _formatter;
 
@@ skipping 206 matching lines @@
 
       if (comment.linesBefore == 0) {
         // If we're sitting on a split, move the comment before it to adhere it
         // to the preceding text.
         if (_shouldMoveCommentBeforeSplit(comment.text)) {
           _chunks.last.allowText();
         }
 
         // The comment follows other text, so we need to decide if it gets a
         // space before it or not.
-        if (_needsSpaceBeforeComment(isLineComment: comment.isLineComment)) {
-          _writeText(" ");
-        }
+        if (_needsSpaceBeforeComment(comment)) _writeText(" ");
       } else {
         // The comment starts a line, so make sure it stays on its own line.
         _writeHardSplit(
             flushLeft: comment.flushLeft,
             isDouble: comment.linesBefore > 1,
             nest: true);
       }
 
       _writeText(comment.text);
 
@@ skipping 351 matching lines @@
 
     // Multi-line comments are always pushed to the next line.
     if (comment.contains("\n")) return false;
 
     // If the text before the split is an open grouping character, we don't
     // want to adhere the comment to that.
     var text = _chunks.last.text;
     return !text.endsWith("(") && !text.endsWith("[") && !text.endsWith("{");
   }
 
+  /// Returns `true` if [comment] appears to be a magic generic method comment.
+  ///
+  /// Those get spaced a little differently to look more like real syntax:
+  ///
+  ///     int f/*<S, T>*/(int x) => 3;
+  bool _isGenericMethodComment(SourceComment comment) {
+    return comment.text.startsWith("/*<") || comment.text.startsWith("/*=");
+  }
+
   /// Returns `true` if a space should be output between the end of the current
   /// output and the subsequent comment which is about to be written.
   ///
   /// This is only called if the comment is trailing text in the unformatted
   /// source. In most cases, a space will be output to separate the comment
   /// from what precedes it. This returns false if:
   ///
   /// *   This comment does begin the line in the output even if it didn't in
   ///     the source.
   /// *   The comment is a block comment immediately following a grouping
   ///     character (`(`, `[`, or `{`). This is to allow `foo(/* comment */)`,
   ///     et. al.
-  bool _needsSpaceBeforeComment({bool isLineComment}) {
+  bool _needsSpaceBeforeComment(SourceComment comment) {
     // Not at the start of the file.
     if (_chunks.isEmpty) return false;
 
     // Not at the start of a line.
     if (!_chunks.last.canAddText) return false;
 
     var text = _chunks.last.text;
     if (text.endsWith("\n")) return false;
 
     // Always put a space before line comments.
-    if (isLineComment) return true;
+    if (comment.isLineComment) return true;
+
+    // Magic generic method comments like "Foo/*<T>*/" don't get spaces.
+    if (_isGenericMethodComment(comment) &&
+        _trailingIdentifierChar.hasMatch(text)) {
+      return false;
+    }
 
     // Block comments do not get a space if following a grouping character.
     return !text.endsWith("(") && !text.endsWith("[") && !text.endsWith("{");
   }
 
   /// Returns `true` if a space should be output after the last comment which
   /// was just written and the token that will be written.
   bool _needsSpaceAfterLastComment(List<SourceComment> comments, String token) {
     // Not if there are no comments.
     if (comments.isEmpty) return false;
 
     // Not at the beginning of a line.
     if (!_chunks.last.canAddText) return false;
 
+    // Magic generic method comments like "Foo/*<T>*/" don't get spaces.
+    if (_isGenericMethodComment(comments.last) && token == "(") {
+      return false;
+    }
+
     // Otherwise, it gets a space if the following token is not a delimiter or
     // the empty string, for EOF.
     return token != ")" &&
         token != "]" &&
         token != "}" &&
         token != "," &&
         token != ";" &&
         token != "";
   }
 
@@ skipping 116 matching lines @@
 
     // Discard spans in hardened chunks since we know for certain they will
     // split anyway.
     for (var chunk in _chunks) {
       if (chunk.rule != null && chunk.rule.isHardened) {
         chunk.spans.clear();
       }
     }
   }
 }