Clean up type parameters in comments

pkg/analyzer/lib/src/generated/type_system.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.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
@@ skipping 248 matching lines @@
   ///
   /// For each parameter Pi, we want to ensure that Ai <: Pi. We can do this by
   /// running the subtype algorithm, and when we reach a type parameter Tj,
   /// recording the lower or upper bound it must satisfy. At the end, all
   /// constraints can be combined to determine the type.
   ///
   /// All constraints on each type parameter Tj are tracked, as well as where
   /// they originated, so we can issue an error message tracing back to the
   /// argument values, type parameter "extends" clause, or the return type
   /// context.
-  /*=T*/ inferGenericFunctionOrType/*<T extends ParameterizedType>*/(
-      /*=T*/ genericType,
+  T inferGenericFunctionOrType<T extends ParameterizedType>(
+      T genericType,
       List<ParameterElement> parameters,
       List<DartType> argumentTypes,
       DartType returnContextType,
       {ErrorReporter errorReporter,
       AstNode errorNode,
       bool downwards: false}) {
     // TODO(jmesserly): expose typeFormals on ParameterizedType.
     List<TypeParameterElement> typeFormals = typeFormalsAsElements(genericType);
     if (typeFormals.isEmpty) {
       return genericType;
@@ skipping 790 matching lines @@
       return getLeastUpperBound(type1, type2);
     }
     // We should only be called when at least one of the types is a
     // TypeParameterType
     type2 = type2
         .resolveToBound(typeProvider.objectType)
         .substitute2([typeProvider.objectType], [type2]);
     return getLeastUpperBound(type1, type2);
   }
 
-  static List/*<T>*/ _transformList/*<T>*/(
-      List/*<T>*/ list, /*=T*/ f(/*=T*/ t)) {
-    List/*<T>*/ newList = null;
+  static List<T> _transformList<T>(List<T> list, T f(T t)) {
+    List<T> newList = null;
     for (var i = 0; i < list.length; i++) {
       var item = list[i];
       var newItem = f(item);
       if (!identical(item, newItem)) {
         newList ??= new List.from(list);
         newList[i] = newItem;
       }
     }
     return newList ?? list;
   }
@@ skipping 546 matching lines @@
     setModifier(Modifier.SYNTHETIC, true);
   }
 
   @override
   ElementKind get kind => ElementKind.DYNAMIC;
 
   @override
   UnknownInferredType get type => UnknownInferredType.instance;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor visitor) => null;
+  T accept<T>(ElementVisitor visitor) => null;
 }
 
 /// Tracks upper and lower type bounds for a set of type parameters.
 ///
 /// This class is used by calling [isSubtypeOf]. When it encounters one of
 /// the type parameters it is inferring, it will record the constraint, and
 /// optimistically assume the constraint will be satisfied.
 ///
 /// For example if we are inferring type parameter A, and we ask if
 /// `A <: num`, this will record that A must be a subytpe of `num`. It also
@@ skipping 67 matching lines @@
   }
 
   /// Given the constraints that were given by calling [isSubtypeOf], find the
   /// instantiation of the generic function that satisfies these constraints.
   ///
   /// If [downwardsInferPhase] is set, we are in the first pass of inference,
   /// pushing context types down. At that point we are allowed to push down
   /// `?` to precisely represent an unknown type. If [downwardsInferPhase] is
   /// false, we are on our final inference pass, have all available information
   /// including argument types, and must not conclude `?` for any type formal.
-  /*=T*/ infer/*<T extends ParameterizedType>*/(
-      /*=T*/ genericType,
-      List<TypeParameterElement> typeFormals,
+  T infer<T extends ParameterizedType>(
+      T genericType, List<TypeParameterElement> typeFormals,
       {ErrorReporter errorReporter,
       AstNode errorNode,
       bool downwardsInferPhase: false}) {
     var fnTypeParams = TypeParameterTypeImpl.getTypes(typeFormals);
 
     // Initialize the inferred type array.
     //
     // In the downwards phase, they all start as `?` to offer reasonable
     // degradation for f-bounded type parameters.
     var inferredTypes = new List<DartType>.filled(
@@ skipping 12 matching lines @@
             typeParam.bound.substitute2(inferredTypes, fnTypeParams));
       }
 
       var constraints = _constraints[typeParam.element];
       inferredTypes[i] = _inferTypeParameter(constraints, extendsClause);
     }
 
     // If the downwards infer phase has failed, we'll catch this in the upwards
     // phase later on.
     if (downwardsInferPhase) {
-      return genericType.instantiate(inferredTypes) as dynamic/*=T*/;
+      return genericType.instantiate(inferredTypes) as T;
     }
 
     // Check the inferred types against all of the constraints.
     var knownTypes = new HashMap<TypeParameterType, DartType>(
         equals: (x, y) => x.element == y.element,
         hashCode: (x) => x.element.hashCode);
     for (int i = 0; i < fnTypeParams.length; i++) {
       TypeParameterType typeParam = fnTypeParams[i];
       var constraints = _constraints[typeParam.element];
       var typeParamBound =
@@ skipping 23 matching lines @@
       }
 
       if (UnknownInferredType.isKnown(inferred)) {
         knownTypes[typeParam] = inferred;
       }
     }
 
     // Use instantiate to bounds to finish things off.
     var hasError = new List<bool>.filled(fnTypeParams.length, false);
     var result = _typeSystem.instantiateToBounds(genericType,
-        hasError: hasError, knownTypes: knownTypes) as dynamic/*=T*/;
+        hasError: hasError, knownTypes: knownTypes) as T;
 
     // Report any errors from instantiateToBounds.
     for (int i = 0; i < hasError.length; i++) {
       if (hasError[i]) {
         TypeParameterType typeParam = fnTypeParams[i];
         var typeParamBound =
             typeParam.bound.substitute2(inferredTypes, fnTypeParams);
         // TODO(jmesserly): improve this error message.
         errorReporter
             ?.reportErrorForNode(StrongModeCode.COULD_NOT_INFER, errorNode, [
@@ skipping 548 matching lines @@
   /// Combining these constraints results in a lower bound of `num`.
   ///
   /// In general, we choose the lower bound as our inferred type, so we can
   /// offer the most constrained (strongest) result type.
   final DartType lowerBound;
 
   _TypeRange({DartType lower, DartType upper})
       : lowerBound = lower ?? UnknownInferredType.instance,
         upperBound = upper ?? UnknownInferredType.instance;
 }