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

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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 dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart' show BoxLocal;
 import '../common.dart';
@@ skipping 233 matching lines @@
   }
 
   void _ensureThisAndRawType(ClassEntity cls, ClassData data) {
     assert(checkFamily(cls));
     if (data.thisType == null) {
       ir.Class node = data.cls;
       // TODO(johnniwinther): Add the type argument to the list literal when we
       // no longer use resolution types.
       if (node.typeParameters.isEmpty) {
         data.thisType =
-            data.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
+            data.rawType = new InterfaceType(cls, const <DartType>[]);
       } else {
         data.thisType = new InterfaceType(
             cls,
-            new List/*<DartType>*/ .generate(node.typeParameters.length,
+            new List<DartType>.generate(node.typeParameters.length,
                 (int index) {
               return new TypeVariableType(
                   _getTypeVariable(node.typeParameters[index]));
             }));
         data.rawType = new InterfaceType(
             cls,
-            new List/*<DartType>*/ .filled(
+            new List<DartType>.filled(
                 node.typeParameters.length, const DynamicType()));
       }
     }
   }
 
   TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
       _getTypeVariable(node);
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node);
 
@@ skipping 114 matching lines @@
   FieldEntity getField(ir.Field node) => _getField(node);
 
   FieldEntity _getField(ir.Field node);
 
   @override
   DartType getDartType(ir.DartType type) => _typeConverter.convert(type);
 
   List<DartType> getDartTypes(List<ir.DartType> types) {
     // TODO(johnniwinther): Add the type argument to the list literal when we
     // no longer use resolution types.
-    List<DartType> list = /*<DartType>*/ [];
+    List<DartType> list = <DartType>[];
     types.forEach((ir.DartType type) {
       list.add(getDartType(type));
     });
     return list;
   }
 
   @override
   InterfaceType getInterfaceType(ir.InterfaceType type) =>
       _typeConverter.convert(type);
 
   @override
   FunctionType getFunctionType(ir.FunctionNode node) {
     DartType returnType;
     if (node.parent is ir.Constructor) {
       // The return type on generative constructors is `void`, but we need
       // `dynamic` type to match the element model.
       returnType = const DynamicType();
     } else {
       returnType = getDartType(node.returnType);
     }
-    List<DartType> parameterTypes = /*<DartType>*/ [];
-    List<DartType> optionalParameterTypes = /*<DartType>*/ [];
+    List<DartType> parameterTypes = <DartType>[];
+    List<DartType> optionalParameterTypes = <DartType>[];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
       if (parameterTypes.length == node.requiredParameterCount) {
         optionalParameterTypes.add(getDartType(variable.type));
       } else {
         parameterTypes.add(getDartType(variable.type));
       }
     }
     List<String> namedParameters = <String>[];
-    List<DartType> namedParameterTypes = /*<DartType>*/ [];
+    List<DartType> namedParameterTypes = <DartType>[];
     List<ir.VariableDeclaration> sortedNamedParameters =
         node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
     for (ir.VariableDeclaration variable in sortedNamedParameters) {
       namedParameters.add(variable.name);
       namedParameterTypes.add(getDartType(variable.type));
     }
     return new FunctionType(returnType, parameterTypes, optionalParameterTypes,
         namedParameters, namedParameterTypes);
   }
 
@@ skipping 1550 matching lines @@
     Map<String, MemberEntity> memberMap = <String, MemberEntity>{};
     _classEnvs.add(new ClosureClassEnv(memberMap));
 
     // Create a classData and set up the interfaces and subclass
     // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
     var closureData = new ClassData(null,
         new ClosureClassDefinition(cls, computeSourceSpanFromTreeNode(node)));
     closureData
       ..isMixinApplication = false
       ..thisType =
-          closureData.rawType = new InterfaceType(cls, const/*<DartType>*/ [])
+          closureData.rawType = new InterfaceType(cls, const <DartType>[])
       ..supertype = supertype
       ..interfaces = const <InterfaceType>[];
     var setBuilder = new _KernelOrderedTypeSetBuilder(this, cls);
     _classData.add(closureData);
     closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
         closureData.supertype, const Link<InterfaceType>());
 
     int i = 0;
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // Make a corresponding field entity in this closure class for every
@@ skipping 114 matching lines @@
   ///
   /// These names are not used in generated code, just as element name.
   String _getClosureVariableName(String name, int id) {
     return "_captured_${name}_$id";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }