Replace comment style generic method syntax with real syntax (TBR)

pkg/analyzer/lib/task/model.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.
 
 library analyzer.task.model;
 
 import 'dart:collection';
 import 'dart:developer';
 
 import 'package:analyzer/error/error.dart' show AnalysisError;
@@ skipping 158 matching lines @@
     if (inputs == null || !inputs.containsKey(name)) {
       return null;
     }
     return inputs[name];
   }
 
   /**
    * Return the value of the input with the given [name]. Throw an exception if
    * the input value is not defined.
    */
-  Object/*=E*/ getRequiredInput/*<E>*/(String name) {
+  E getRequiredInput<E>(String name) {
     if (inputs == null || !inputs.containsKey(name)) {
       throw new AnalysisException("Could not $description: missing $name");
     }
-    return inputs[name] as Object/*=E*/;
+    return inputs[name] as E;
   }
 
   /**
    * Return the source associated with the target. Throw an exception if
    * the target is not associated with a source.
    */
   Source getRequiredSource() {
     Source source = target.source;
     if (source == null) {
       throw new AnalysisException("Could not $description: missing source");
@@ skipping 167 matching lines @@
  * A description of an input to an [AnalysisTask] that can be used to compute
  * that input.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ListTaskInput<E> implements TaskInput<List<E>> {
   /**
    * Return a task input that can be used to compute a flatten list whose
    * elements are combined [subListResult]'s associated with those elements.
    */
-  ListTaskInput/*<V>*/ toFlattenListOf/*<V>*/(
-      ListResultDescriptor/*<V>*/ subListResult);
+  ListTaskInput<V> toFlattenListOf<V>(ListResultDescriptor<V> subListResult);
 
   /**
    * Return a task input that can be used to compute a list whose elements are
    * the result of passing the elements of this input to the [mapper] function.
    */
-  ListTaskInput/*<V>*/ toList/*<V>*/(UnaryFunction<E, dynamic/*=V*/ > mapper);
+  ListTaskInput<V> toList<V>(UnaryFunction<E, V> mapper);
 
   /**
    * Return a task input that can be used to compute a list whose elements are
    * [valueResult]'s associated with those elements.
    */
-  ListTaskInput/*<V>*/ toListOf/*<V>*/(ResultDescriptor/*<V>*/ valueResult);
+  ListTaskInput<V> toListOf<V>(ResultDescriptor<V> valueResult);
 
   /**
    * Return a task input that can be used to compute a map whose keys are the
    * elements of this input and whose values are the result of passing the
    * corresponding key to the [mapper] function.
    */
-  MapTaskInput<E, dynamic/*=V*/ > toMap/*<V>*/(
-      UnaryFunction<E, dynamic/*=V*/ > mapper);
+  MapTaskInput<E, V> toMap<V>(UnaryFunction<E, V> mapper);
 
   /**
    * Return a task input that can be used to compute a map whose keys are the
    * elements of this input and whose values are the [valueResult]'s associated
    * with those elements.
    */
-  MapTaskInput<AnalysisTarget, dynamic/*=V*/ > toMapOf/*<V>*/(
-      ResultDescriptor/*<V>*/ valueResult);
+  MapTaskInput<AnalysisTarget, V> toMapOf<V>(ResultDescriptor<V> valueResult);
 }
 
 /**
  * A description of an input with a [Map] based values.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapTaskInput<K, V> implements TaskInput<Map<K, V>> {
   /**
    * [V] must be a [List].
    * Return a task input that can be used to compute a list whose elements are
    * the result of passing keys [K] and the corresponding elements of [V] to
    * the [mapper] function.
    */
-  TaskInput<List/*<E>*/ > toFlattenList/*<E>*/(
-      BinaryFunction<K, dynamic /*element of V*/, dynamic/*=E*/ > mapper);
+  TaskInput<List<E>> toFlattenList<E>(
+      BinaryFunction<K, dynamic /*element of V*/, E> mapper);
 }
 
 /**
  * Instances of this class are thrown when a task detects that the modification
  * time of a cache entry is not the same as the actual modification time.  This
  * means that any analysis results based on the content of the target cannot be
  * used anymore and must be invalidated.
  */
 class ModificationTimeMismatchError {
   final Source source;
@@ skipping 173 matching lines @@
 abstract class TaskInput<V> {
   /**
    * Create and return a builder that can be used to build this task input.
    */
   TaskInputBuilder<V> createBuilder();
 
   /**
    * Return a task input that can be used to compute a list whose elements are
    * the result of passing the result of this input to the [mapper] function.
    */
-  ListTaskInput/*<E>*/ mappedToList/*<E>*/(List/*<E>*/ mapper(V value));
+  ListTaskInput<E> mappedToList<E>(List<E> mapper(V value));
 }
 
 /**
  * An object used to build the value associated with a single [TaskInput].
  *
  * All builders work by requesting one or more results (each result being
  * associated with a target). The interaction pattern is modeled after the class
  * [Iterator], in which the method [moveNext] is invoked to move from one result
  * request to the next. The getters [currentResult] and [currentTarget] are used
  * to get the result and target of the current request. The value of the result
@@ skipping 156 matching lines @@
   /**
    * A work should be done, but without any special urgency.
    */
   NORMAL,
 
   /**
    * Nothing to do.
    */
   NONE
 }