fix #25739, incorrectly expanding a generic comment multiple times

pkg/analyzer/test/src/task/strong/strong_test_helper.dart

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this file needs to be refactored, it's a port from
 // package:dev_compiler's tests
 library analyzer.test.src.task.strong.strong_test_helper;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 56 matching lines @@
       new SourceFactory([new DartUriResolver(new MockSdk()), uriResolver]);
 
   // Run the checker on /main.dart.
   Source mainSource = uriResolver.resolveAbsolute(new Uri.file('/main.dart'));
   var initialLibrary = context.resolveCompilationUnit2(mainSource, mainSource);
 
   var collector = new _ErrorCollector();
 
   // Extract expectations from the comments in the test files, and
   // check that all errors we emit are included in the expected map.
-  var allLibraries = reachableLibraries(initialLibrary.element.library);
+  var allLibraries = _reachableLibraries(initialLibrary.element.library);
   for (var lib in allLibraries) {
     for (var unit in lib.units) {
       var errors = <AnalysisError>[];
       collector.errors = errors;
 
       var source = unit.source;
       if (source.uri.scheme == 'dart') continue;
 
       var librarySource = context.getLibrariesContaining(source).single;
       var resolved = context.resolveCompilationUnit2(source, librarySource);
       errors.addAll(context.getErrors(source).errors.where((e) =>
           e.errorCode != HintCode.UNUSED_LOCAL_VARIABLE &&
           // TODO(jmesserly): these are usually intentional dynamic calls.
           e.errorCode.name != 'UNDEFINED_METHOD'));
 
       _expectErrors(resolved, errors);
     }
   }
 }
 
 /// Adds a file using [addFile] and calls [check].
 void checkFile(String content) {
   addFile(content);
   check();
 }
 
-SourceSpanWithContext createSpanHelper(
+SourceSpanWithContext _createSpanHelper(
     LineInfo lineInfo, int start, Source source, String content,
     {int end}) {
-  var startLoc = locationForOffset(lineInfo, source.uri, start);
-  var endLoc = locationForOffset(lineInfo, source.uri, end ?? start);
+  var startLoc = _locationForOffset(lineInfo, source.uri, start);
+  var endLoc = _locationForOffset(lineInfo, source.uri, end ?? start);
 
   var lineStart = startLoc.offset - startLoc.column;
   // Find the end of the line. This is not exposed directly on LineInfo, but
   // we can find it pretty easily.
   // TODO(jmesserly): for now we do the simple linear scan. Ideally we can get
   // some help from the LineInfo API.
   int lineEnd = endLoc.offset;
   int lineNum = lineInfo.getLocation(lineEnd).lineNumber;
   while (lineEnd < content.length &&
       lineInfo.getLocation(++lineEnd).lineNumber == lineNum);
 
   if (end == null) {
     end = lineEnd;
-    endLoc = locationForOffset(lineInfo, source.uri, lineEnd);
+    endLoc = _locationForOffset(lineInfo, source.uri, lineEnd);
   }
 
   var text = content.substring(start, end);
   var lineText = content.substring(lineStart, lineEnd);
   return new SourceSpanWithContext(startLoc, endLoc, text, lineText);
 }
 
 String _errorCodeName(ErrorCode errorCode) {
   var name = errorCode.name;
   final prefix = 'STRONG_MODE_';
   if (name.startsWith(prefix)) {
     return name.substring(prefix.length);
   } else {
     return name;
   }
 }
 
-initStrongModeTests() {
+void initStrongModeTests() {
   setUp(() {
     AnalysisEngine.instance.processRequiredPlugins();
     files = new MemoryResourceProvider();
     _checkCalled = false;
   });
 
   tearDown(() {
     // This is a sanity check, in case only addFile is called.
     expect(_checkCalled, true, reason: 'must call check() method in test case');
     files = null;
   });
 }
 
-// TODO(jmesserly): can we reuse the same mock SDK as Analyzer tests?
-SourceLocation locationForOffset(LineInfo lineInfo, Uri uri, int offset) {
+SourceLocation _locationForOffset(LineInfo lineInfo, Uri uri, int offset) {
   var loc = lineInfo.getLocation(offset);
   return new SourceLocation(offset,
       sourceUrl: uri, line: loc.lineNumber - 1, column: loc.columnNumber - 1);
 }
 
 /// Returns all libraries transitively imported or exported from [start].
-List<LibraryElement> reachableLibraries(LibraryElement start) {
+List<LibraryElement> _reachableLibraries(LibraryElement start) {
   var results = <LibraryElement>[];
   var seen = new Set();
   void find(LibraryElement lib) {
     if (seen.contains(lib)) return;
     seen.add(lib);
     results.add(lib);
     lib.importedLibraries.forEach(find);
     lib.exportedLibraries.forEach(find);
   }
   find(start);
@@ skipping 57 matching lines @@
 
 List<_ErrorExpectation> _findExpectedErrors(Token beginToken) {
   var expectedErrors = <_ErrorExpectation>[];
 
   // Collect expectations like "severe:STATIC_TYPE_ERROR" from comment tokens.
   for (Token t = beginToken; t.type != TokenType.EOF; t = t.next) {
     for (CommentToken c = t.precedingComments; c != null; c = c.next) {
       if (c.type == TokenType.MULTI_LINE_COMMENT) {
         String value = c.lexeme.substring(2, c.lexeme.length - 2);
         if (value.contains(':')) {
-          var offset = c.end;
-          if (c.next?.type == TokenType.GENERIC_METHOD_TYPE_LIST) {
-            offset += 2;
+          int offset = t.offset;
+          Token previous = t.previous;
+          while (previous != null && previous.offset > c.offset) {
+            offset = previous.offset;
+            previous = previous.previous;
           }
           for (var expectCode in value.split(',')) {
             var expected = _ErrorExpectation.parse(offset, expectCode);
             if (expected != null) {
               expectedErrors.add(expected);
             }
           }
         }
       }
     }
   }
   return expectedErrors;
 }
 
 void _reportFailure(
     CompilationUnit unit,
     List<_ErrorExpectation> unreported,
     List<AnalysisError> unexpected,
     Map<_ErrorExpectation, AnalysisError> different) {
   // Get the source code. This reads the data again, but it's safe because
   // all tests use memory file system.
   var sourceCode = unit.element.source.contents.data;
 
   String formatActualError(AnalysisError error) {
     int offset = error.offset;
     int length = error.length;
-    var span = createSpanHelper(
+    var span = _createSpanHelper(
         unit.lineInfo, offset, unit.element.source, sourceCode,
         end: offset + length);
     var levelName = _actualErrorLevel(error).name.toLowerCase();
     return '@$offset $levelName:${_errorCodeName(error.errorCode)}\n' +
         span.message(error.message);
   }
 
   String formatExpectedError(_ErrorExpectation error) {
     int offset = error.offset;
-    var span = createSpanHelper(
+    var span = _createSpanHelper(
         unit.lineInfo, offset, unit.element.source, sourceCode);
     var levelName = error.level.toString().toLowerCase();
     return '@$offset $levelName:${error.typeName}\n' + span.message('');
   }
 
   var message = new StringBuffer();
   if (unreported.isNotEmpty) {
     message.writeln('Expected errors that were not reported:');
     unreported.map(formatExpectedError).forEach(message.writeln);
     message.writeln();
@@ skipping 87 matching lines @@
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     if (uri.scheme == 'package') {
       return (provider.getResource('/packages/' + uri.path) as File)
           .createSource(uri);
     }
     return super.resolveAbsolute(uri, actualUri);
   }
 }