Reapply "Add support for generic function type syntax, part 1"

pkg/analyzer/lib/src/dart/constant/evaluation.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.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1340 matching lines @@
       if (elementResult == null) {
         errorOccurred = true;
       } else {
         elements.add(elementResult);
       }
     }
     if (errorOccurred) {
       return null;
     }
     DartType elementType = _typeProvider.dynamicType;
-    NodeList<TypeName> typeArgs = node.typeArguments?.arguments;
+    NodeList<TypeAnnotation> typeArgs = node.typeArguments?.arguments;
     if (typeArgs?.length == 1) {
-      DartType type = visitTypeName(typeArgs[0])?.toTypeValue();
+      DartType type = visitTypeAnnotation(typeArgs[0])?.toTypeValue();
       if (type != null) {
         elementType = type;
       }
     }
     InterfaceType listType = _typeProvider.listType.instantiate([elementType]);
     return new DartObjectImpl(listType, new ListState(elements));
   }
 
   @override
   DartObjectImpl visitMapLiteral(MapLiteral node) {
@@ skipping 12 matching lines @@
         errorOccurred = true;
       } else {
         map[keyResult] = valueResult;
       }
     }
     if (errorOccurred) {
       return null;
     }
     DartType keyType = _typeProvider.dynamicType;
     DartType valueType = _typeProvider.dynamicType;
-    NodeList<TypeName> typeArgs = node.typeArguments?.arguments;
+    NodeList<TypeAnnotation> typeArgs = node.typeArguments?.arguments;
     if (typeArgs?.length == 2) {
-      DartType keyTypeCandidate = visitTypeName(typeArgs[0])?.toTypeValue();
+      DartType keyTypeCandidate =
+          visitTypeAnnotation(typeArgs[0])?.toTypeValue();
       if (keyTypeCandidate != null) {
         keyType = keyTypeCandidate;
       }
-      DartType valueTypeCandidate = visitTypeName(typeArgs[1])?.toTypeValue();
+      DartType valueTypeCandidate =
+          visitTypeAnnotation(typeArgs[1])?.toTypeValue();
       if (valueTypeCandidate != null) {
         valueType = valueTypeCandidate;
       }
     }
     InterfaceType mapType =
         _typeProvider.mapType.instantiate([keyType, valueType]);
     return new DartObjectImpl(mapType, new MapState(map));
   }
 
   @override
@@ skipping 129 matching lines @@
     for (int i = 0; i < components.length; i++) {
       if (i > 0) {
         buffer.writeCharCode(0x2E);
       }
       buffer.write(components[i].lexeme);
     }
     return new DartObjectImpl(
         _typeProvider.symbolType, new SymbolState(buffer.toString()));
   }
 
-  @override
-  DartObjectImpl visitTypeName(TypeName node) {
+  DartObjectImpl visitTypeAnnotation(TypeAnnotation node) {
     DartType type = evaluateType(node.type);
     if (type == null) {
       return super.visitTypeName(node);
     }
     return typeConstant(type);
   }
 
+  @override
+  DartObjectImpl visitTypeName(TypeName node) => visitTypeAnnotation(node);
+
   /**
    * Create an error associated with the given [node]. The error will have the
    * given error [code].
    */
   void _error(AstNode node, ErrorCode code) {
     _errorReporter.reportErrorForNode(
         code ?? CompileTimeErrorCode.INVALID_CONSTANT, node);
   }
 
   /**
@@ skipping 509 matching lines @@
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }