Clean up type parameters in comments

pkg/analyzer/lib/src/dart/element/element.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.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 98 matching lines @@
     this._fields = fields;
   }
 
   @override
   bool get isEnum;
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitClassElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitClassElement(this);
 
   @override
   NamedCompilationUnitMember computeNode() {
     if (isEnum) {
       return getNodeMatching((node) => node is EnumDeclaration);
     } else {
       return getNodeMatching(
           (node) => node is ClassDeclaration || node is ClassTypeAlias);
     }
   }
@@ skipping 121 matching lines @@
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(accessors, visitor);
     safelyVisitChildren(fields, visitor);
   }
 
   /**
    * Return the first element from the given [iterable], or `null` if the
    * iterable is empty.
    */
-  Object/*=E*/ _first/*<E>*/(Iterable/*<E>*/ iterable) {
+  E _first<E>(Iterable<E> iterable) {
     if (iterable.isEmpty) {
       return null;
     }
     return iterable.first;
   }
 
   /**
    * Return an iterable containing all of the implementations of a getter with
    * the given [getterName] that are defined in this class any any superclass of
    * this class (but not in interfaces).
@@ skipping 1332 matching lines @@
       }
     }
     this._types = types;
   }
 
   @override
   bool operator ==(Object object) =>
       object is CompilationUnitElementImpl && source == object.source;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitCompilationUnitElement(this);
 
   /**
    * This method is invoked after this unit was incrementally resolved.
    */
   void afterIncrementalResolution() {
     _offsetToElementMap.clear();
   }
 
   @override
@@ skipping 534 matching lines @@
   @override
   FunctionType get type {
     return _type ??= new FunctionTypeImpl(this);
   }
 
   void set type(FunctionType type) {
     assert(false);
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitConstructorElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     if (enclosingElement == null) {
       String message;
       String name = displayName;
       if (name != null && !name.isEmpty) {
         message =
             'Found constructor element named $name with no enclosing element';
@@ skipping 246 matching lines @@
    * through the method [instance].
    */
   DynamicElementImpl() : super(Keyword.DYNAMIC.lexeme, -1) {
     setModifier(Modifier.SYNTHETIC, true);
   }
 
   @override
   ElementKind get kind => ElementKind.DYNAMIC;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) => null;
+  T accept<T>(ElementVisitor<T> visitor) => null;
 }
 
 /**
  * A concrete implementation of an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The name of the top-level variable used to mark a method parameter as
    * covariant.
    */
@@ skipping 570 matching lines @@
   AstNode computeNode() => getNodeMatching((node) => node is AstNode);
 
   /**
    * Set this element as the enclosing element for given [element].
    */
   void encloseElement(ElementImpl element) {
     element.enclosingElement = this;
   }
 
   @override
-  Element/*=E*/ getAncestor/*<E extends Element >*/(
-      Predicate<Element> predicate) {
+  E getAncestor<E extends Element>(Predicate<Element> predicate) {
     Element ancestor = _enclosingElement;
     while (ancestor != null && !predicate(ancestor)) {
       ancestor = ancestor.enclosingElement;
     }
-    return ancestor as Element/*=E*/;
+    return ancestor as E;
   }
 
   /**
    * Return the child of this element that is uniquely identified by the given
    * [identifier], or `null` if there is no such child.
    */
   ElementImpl getChild(String identifier) => null;
 
   @override
   String getExtendedDisplayName(String shortName) {
@@ skipping 1113 matching lines @@
     return super.uriOffset;
   }
 
   @override
   void set uriOffset(int uriOffset) {
     _assertNotResynthesized(_unlinkedExportNonPublic);
     super.uriOffset = uriOffset;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitExportElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitExportElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("export ");
     LibraryElementImpl.getImpl(exportedLibrary).appendTo(buffer);
   }
 }
 
 /**
  * A concrete implementation of a [FieldElement].
@@ skipping 75 matching lines @@
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   bool get isVirtual => true;
 
   @override
   ElementKind get kind => ElementKind.FIELD;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitFieldElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitFieldElement(this);
 
   @override
   AstNode computeNode() {
     if (isEnumConstant) {
       return getNodeMatching((node) => node is EnumConstantDeclaration);
     } else {
       return getNodeMatching((node) => node is VariableDeclaration);
     }
   }
 }
@@ skipping 62 matching lines @@
     return super.type;
   }
 
   @override
   void set type(DartType type) {
     _assertNotResynthesized(_unlinkedParam);
     _type = type;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitFieldFormalParameterElement(this);
 }
 
 /**
  * A concrete implementation of a [FunctionElement].
  */
 class FunctionElementImpl extends ExecutableElementImpl
     implements FunctionElement {
   /**
    * The offset to the beginning of the visible range for this element.
@@ skipping 81 matching lines @@
       return new SourceRange(serializedExecutable.visibleOffset,
           serializedExecutable.visibleLength);
     }
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitFunctionElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitFunctionElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     String name = displayName;
     if (name != null) {
       buffer.write(name);
     }
     super.appendTo(buffer);
   }
 
@@ skipping 300 matching lines @@
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameterElements = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedTypedef?.typeParameters;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitFunctionTypeAliasElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("typedef ");
     buffer.write(displayName);
     List<TypeParameterElement> typeParameters = this.typeParameters;
     int typeParameterCount = typeParameters.length;
     if (typeParameterCount > 0) {
       buffer.write("<");
@@ skipping 390 matching lines @@
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameterElements = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedTypedef?.typeParameters;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitFunctionTypeAliasElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("typedef ");
     buffer.write(displayName);
     var typeParameters = this.typeParameters;
     int typeParameterCount = typeParameters.length;
     if (typeParameterCount > 0) {
       buffer.write("<");
@@ skipping 333 matching lines @@
     return super.uriOffset;
   }
 
   @override
   void set uriOffset(int uriOffset) {
     _assertNotResynthesized(_unlinkedImport);
     super.uriOffset = uriOffset;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitImportElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitImportElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("import ");
     LibraryElementImpl.getImpl(importedLibrary).appendTo(buffer);
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
@@ skipping 108 matching lines @@
     int offset = super.nameOffset;
     if (offset == 0 &&
         _unlinkedLabel != null &&
         _unlinkedLabel.nameOffset != 0) {
       return _unlinkedLabel.nameOffset;
     }
     return offset;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitLabelElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitLabelElement(this);
 
   /**
    * Create and return [LabelElement]s for the given [unlinkedLabels].
    */
   static List<LabelElement> resynthesizeList(
       ExecutableElementImpl enclosingExecutable,
       List<UnlinkedLabel> unlinkedLabels) {
     int length = unlinkedLabels.length;
     if (length != 0) {
       List<LabelElement> elements = new List<LabelElement>(length);
@@ skipping 530 matching lines @@
 
   @override
   List<CompilationUnitElement> get units {
     List<CompilationUnitElement> units = new List<CompilationUnitElement>();
     units.add(_definingCompilationUnit);
     units.addAll(_parts);
     return units;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitLibraryElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitLibraryElement(this);
 
   /**
    * Create the [FunctionElement] to be returned by [loadLibraryFunction],
    * using types provided by [typeProvider].
    */
   void createLoadLibraryFunction(TypeProvider typeProvider) {
     FunctionElementImpl function =
         new FunctionElementImpl(FunctionElement.LOAD_LIBRARY_NAME, -1);
     function.isSynthetic = true;
     function.enclosingElement = this;
@@ skipping 279 matching lines @@
       return new SourceRange(
           _unlinkedVariable.visibleOffset, _unlinkedVariable.visibleLength);
     }
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitLocalVariableElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
   @override
@@ skipping 100 matching lines @@
   @override
   String get name {
     String name = super.name;
     if (name == '-' && parameters.isEmpty) {
       return 'unary-';
     }
     return super.name;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitMethodElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitMethodElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(displayName);
     super.appendTo(buffer);
   }
 
   @override
   MethodDeclaration computeNode() =>
       getNodeMatching((node) => node is MethodDeclaration);
@@ skipping 302 matching lines @@
   @override
   Source get source => null;
 
   @override
   DartType get type => DynamicTypeImpl.instance;
 
   @override
   CompilationUnit get unit => null;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitMultiplyDefinedElement(this);
 
   @override
   String computeDocumentationComment() => null;
 
   @override
   AstNode computeNode() => null;
 
   @override
-  Element/*=E*/ getAncestor/*<E extends Element >*/(
-          Predicate<Element> predicate) =>
-      null;
+  E getAncestor<E extends Element>(Predicate<Element> predicate) => null;
 
   @override
   String getExtendedDisplayName(String shortName) {
     if (shortName != null) {
       return shortName;
     }
     return displayName;
   }
 
   @override
@@ skipping 704 matching lines @@
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   /**
    * Subclasses need this getter, see [ConstVariableElement._unlinkedConst].
    */
   UnlinkedExpr get _unlinkedConst => _unlinkedParam?.initializer?.bodyExpr;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitParameterElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitParameterElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     String left = "";
     String right = "";
     while (true) {
       if (parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (parameterKind == ParameterKind.POSITIONAL) {
@@ skipping 238 matching lines @@
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedImport != null) {
       return _unlinkedImport.prefixOffset;
     }
     return offset;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
-      visitor.visitPrefixElement(this);
+  T accept<T>(ElementVisitor<T> visitor) => visitor.visitPrefixElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("as ");
     super.appendTo(buffer);
   }
 }
 
 /**
  * A concrete implementation of a [PropertyAccessorElement].
@@ skipping 151 matching lines @@
 
   /**
    * Set whether this accessor is a setter.
    */
   void set setter(bool isSetter) {
     _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.SETTER, isSetter);
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitPropertyAccessorElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(isGetter ? "get " : "set ");
     buffer.write(variable.displayName);
     super.appendTo(buffer);
   }
 
   @override
@@ skipping 345 matching lines @@
       UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
       : super.forSerialized(unlinkedVariable, enclosingElement);
 
   @override
   bool get isStatic => true;
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitTopLevelVariableElement(this);
 
   @override
   VariableDeclaration computeNode() =>
       getNodeMatching((node) => node is VariableDeclaration);
 }
 
 /**
  * A concrete implementation of a [TypeParameterElement].
  */
@@ skipping 128 matching lines @@
       _type ??= new TypeParameterTypeImpl(this);
     }
     return _type;
   }
 
   void set type(TypeParameterType type) {
     _type = type;
   }
 
   @override
-  /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
+  T accept<T>(ElementVisitor<T> visitor) =>
       visitor.visitTypeParameterElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(displayName);
     if (bound != null) {
       buffer.write(" extends ");
       buffer.write(bound);
     }
   }
@@ skipping 431 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }