Clean up type parameters in comments

pkg/analyzer/lib/src/dart/element/member.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 analyzer.src.dart.element.member;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 41 matching lines @@
   int get nameEnd => baseElement.nameEnd;
 
   @override
   int get periodOffset => baseElement.periodOffset;
 
   @override
   ConstructorElement get redirectedConstructor =>
       from(baseElement.redirectedConstructor, definingType);
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitConstructorElement(this);
 
   @override
   ConstructorDeclaration computeNode() => baseElement.computeNode();
 
   @override
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
@@ skipping 163 matching lines @@
       return FieldMember.from(
           field, substituteFor(field.enclosingElement.type));
     }
     return field;
   }
 
   @override
   bool get isCovariant => baseElement.isCovariant;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitFieldFormalParameterElement(this);
 }
 
 /**
  * A field element defined in a parameterized type where the values of the type
  * parameters are known.
  */
 class FieldMember extends VariableMember implements FieldElement {
   /**
    * Initialize a newly created element to represent a field, based on the
@@ skipping 19 matching lines @@
   bool get isVirtual => baseElement.isVirtual;
 
   @override
   DartType get propagatedType => substituteFor(baseElement.propagatedType);
 
   @override
   PropertyAccessorElement get setter =>
       PropertyAccessorMember.from(baseElement.setter, definingType);
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitFieldElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitFieldElement(this);
 
   @override
   VariableDeclaration computeNode() => baseElement.computeNode();
 
   @override
   String toString() => '$type $displayName';
 
   /**
    * If the given [field]'s type is different when any type parameters from the
    * defining type's declaration are replaced with the actual type arguments
@@ skipping 37 matching lines @@
   @override
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
   bool get isEntryPoint => baseElement.isEntryPoint;
 
   @override
   SourceRange get visibleRange => baseElement.visibleRange;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitFunctionElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitFunctionElement(this);
 
   @override
   FunctionDeclaration computeNode() => baseElement.computeNode();
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write(baseElement.displayName);
     (type as FunctionTypeImpl).appendTo(buffer, new Set.identity());
     return buffer.toString();
@@ skipping 121 matching lines @@
   @override
   CompilationUnit get unit => _baseElement.unit;
 
   @override
   String computeDocumentationComment() => documentationComment;
 
   @override
   AstNode computeNode() => _baseElement.computeNode();
 
   @override
-  Element/*=E*/ getAncestor/*<E extends Element >*/(
-          Predicate<Element> predicate) =>
+  E getAncestor<E extends Element>(Predicate<Element> predicate) =>
       baseElement.getAncestor(predicate);
 
   @override
   String getExtendedDisplayName(String shortName) =>
       _baseElement.getExtendedDisplayName(shortName);
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       _baseElement.isAccessibleIn(library);
 
@@ skipping 55 matching lines @@
       [DartType type])
       : super(baseElement, definingType, type);
 
   @override
   MethodElement get baseElement => super.baseElement as MethodElement;
 
   @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitMethodElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitMethodElement(this);
 
   @override
   MethodDeclaration computeNode() => baseElement.computeNode();
 
   @override
   FunctionType getReifiedType(DartType objectType) =>
       substituteFor(baseElement.getReifiedType(objectType));
 
   @override
   String toString() {
@@ skipping 119 matching lines @@
     return ParameterElement.EMPTY_LIST;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
 
   @override
   SourceRange get visibleRange => baseElement.visibleRange;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitParameterElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitParameterElement(this);
 
   @override
   FormalParameter computeNode() => baseElement.computeNode();
 
   @override
-  Element/*=E*/ getAncestor/*<E extends Element>*/(
-      Predicate<Element> predicate) {
+  E getAncestor<E extends Element>(Predicate<Element> predicate) {
     Element element = baseElement.getAncestor(predicate);
     ParameterizedType definingType = this.definingType;
     if (definingType is InterfaceType) {
       if (element is ConstructorElement) {
-        return ConstructorMember.from(element, definingType) as Element/*=E*/;
+        return ConstructorMember.from(element, definingType) as E;
       } else if (element is MethodElement) {
-        return MethodMember.from(element, definingType) as Element/*=E*/;
+        return MethodMember.from(element, definingType) as E;
       } else if (element is PropertyAccessorElement) {
-        return PropertyAccessorMember.from(element, definingType)
-            as Element/*=E*/;
+        return PropertyAccessorMember.from(element, definingType) as E;
       }
     }
-    return element as Element/*=E*/;
+    return element as E;
   }
 
   @override
   String toString() {
     ParameterElement baseElement = this.baseElement;
     String left = "";
     String right = "";
     while (true) {
       if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
@@ skipping 55 matching lines @@
   @override
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
       return FieldMember.from(variable, definingType);
     }
     return variable;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitPropertyAccessorElement(this);
 
   @override
   String toString() {
     PropertyAccessorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     StringBuffer builder = new StringBuffer();
     if (isGetter) {
       builder.write("get ");
@@ skipping 77 matching lines @@
   int get hashCode => baseElement.hashCode;
 
   @override
   TypeParameterType get type => _type;
 
   @override
   bool operator ==(Object other) =>
       other is TypeParameterMember && baseElement == other.baseElement;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitTypeParameterElement(this);
 
   /**
    * If the given [parameter]'s type is different when any type parameters from
    * the defining type's declaration are replaced with the actual type
    * arguments from the [definingType], create a parameter member representing
    * the given parameter. Return the member that was created, or the base
    * parameter if no member was created.
    */
   static List<TypeParameterElement> from(
@@ skipping 101 matching lines @@
   DartObject computeConstantValue() => baseElement.computeConstantValue();
 
   @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used
     // below so that we can safely invoke them.
     super.visitChildren(visitor);
     baseElement.initializer?.accept(visitor);
   }
 }