Create a public interface for AST nodes and rename the implementation classes

pkg/analyzer/lib/src/generated/element_resolver.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.generated.element_resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 1334 matching lines @@
       if (callMethod != null) {
         return _resolveArgumentsToFunction(false, argumentList, callMethod);
       }
     } else if (type is FunctionType) {
       return _resolveArgumentsToParameters(
           false, argumentList, type.parameters);
     }
     return null;
   }
 
+  DartType _computeMethodInvokeType(MethodInvocation node, Element element) {
+    if (element == null) {
+      return null;
+    }
+
+    DartType invokeType;
+    if (element is PropertyAccessorElement) {
+      invokeType = element.returnType;
+    } else if (element is ExecutableElement) {
+      invokeType = element.type;
+    } else if (element is VariableElement) {
+      invokeType = _promoteManager.getStaticType(element);
+    }
+
+    //
+    // Check for a generic method & apply type arguments if any were passed.
+    //
+    // TODO(jmesserly): support generic "call" methods on InterfaceType.
+    if (invokeType is FunctionType) {
+      FunctionType type = invokeType;
+      List<TypeParameterElement> parameters = type.typeFormals;
+
+      NodeList<TypeName> arguments = node.typeArguments?.arguments;
+      if (arguments != null && arguments.length != parameters.length) {
+        // Wrong number of type arguments. Ignore them
+        arguments = null;
+        _resolver.reportErrorForNode(
+            StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
+            node.methodName,
+            [type, parameters.length, arguments?.length ?? 0]);
+      }
+      if (parameters.isNotEmpty) {
+        if (arguments == null) {
+          invokeType = _resolver.typeSystem.instantiateToBounds(type);
+        } else {
+          invokeType = type.instantiate(arguments.map((n) => n.type).toList());
+        }
+      }
+    }
+
+    return invokeType;
+  }
+
   /**
    * Given an element, computes the type of the invocation.
    *
    * For executable elements (like methods, functions) this is just their type.
    *
    * For variables it is their type taking into account any type promotion.
    *
    * For calls to getters in Dart, we invoke the function that is returned by
    * the getter, so the invoke type is the getter's returnType.
    */
@@ skipping 1201 matching lines @@
     return false;
   }
 }
 
 /**
  * An identifier that can be used to look up names in the lexical scope when
  * there is no identifier in the AST structure. There is no identifier in the
  * AST when the parser could not distinguish between a method invocation and an
  * invocation of a top-level function imported with a prefix.
  */
-class SyntheticIdentifier extends Identifier {
+class SyntheticIdentifier extends IdentifierImpl {
   /**
    * The name of the synthetic identifier.
    */
   final String name;
 
   /**
    * The identifier to be highlighted in case of an error
    */
   final Identifier targetIdentifier;
 
@@ skipping 34 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }