Removed fixed dependencies

packages/analyzer/lib/dart/ast/resolution_map.dart

Index: packages/analyzer/lib/dart/ast/resolution_map.dart
diff --git a/packages/analyzer/lib/dart/ast/resolution_map.dart b/packages/analyzer/lib/dart/ast/resolution_map.dart
new file mode 100644
index 0000000000000000000000000000000000000000..37ee0545ce51b2a3426104f769c58e1eac891238
--- /dev/null
+++ b/packages/analyzer/lib/dart/ast/resolution_map.dart
@@ -0,0 +1,291 @@
+// Copyright (c) 2016, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+
+/**
+ * A collection of methods which may be used to map from nodes in a resolved AST
+ * to elements and types in the element model.
+ *
+ * Clients should not extend, implement or mix-in this class.
+ */
+abstract class ResolutionMap {
+  /**
+   * Return the best element available for the function being invoked at [node].
+   * If resolution was able to find a better element based on type propagation,
+   * that element will be returned. Otherwise, the element found using the
+   * result of static analysis will be returned. If resolution has not been
+   * performed, then `null` will be returned.
+   */
+  ExecutableElement bestElementForFunctionExpressionInvocation(
+      FunctionExpressionInvocation node);
+
+  /**
+   * Return the best element available for the identifier [node]. If resolution
+   * was able to find a better element based on type propagation, that element
+   * will be returned. Otherwise, the element found using the result of static
+   * analysis will be returned. If resolution has not been performed, then
+   * `null` will be returned.
+   */
+  Element bestElementForIdentifier(Identifier node);
+
+  /**
+   * Return the best element available for the expression [node]. If resolution
+   * was able to find a better element based on type propagation, that element
+   * will be returned. Otherwise, the element found using the result of static
+   * analysis will be returned. If resolution has not been performed, then
+   * `null` will be returned.
+   */
+  MethodElement bestElementForMethodReference(MethodReferenceExpression node);
+
+  /**
+   * Return the best parameter element information available for the expression
+   * [node]. If type propagation was able to find a better parameter element
+   * than static analysis, that type will be returned. Otherwise, the result of
+   * static analysis will be returned.
+   */
+  ParameterElement bestParameterElementForExpression(Expression node);
+
+  /**
+   * Return the best type information available for the expression [node]. If
+   * type propagation was able to find a better type than static analysis, that
+   * type will be returned. Otherwise, the result of static analysis will be
+   * returned. If no type analysis has been performed, then the type 'dynamic'
+   * will be returned.
+   */
+  DartType bestTypeForExpression(Expression node);
+
+  /**
+   * Return the element annotation representing the annotation [node] in the
+   * element model.
+   */
+  ElementAnnotation elementAnnotationForAnnotation(Annotation node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  ClassElement elementDeclaredByClassDeclaration(ClassDeclaration node);
+
+  /**
+   * Return the element associated with the compilation unit [node], or `null`
+   * if the AST structure has not been resolved.
+   */
+  CompilationUnitElement elementDeclaredByCompilationUnit(CompilationUnit node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  ConstructorElement elementDeclaredByConstructorDeclaration(
+      ConstructorDeclaration node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  Element elementDeclaredByDeclaration(Declaration node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  LocalVariableElement elementDeclaredByDeclaredIdentifier(
+      DeclaredIdentifier node);
+
+  /**
+   * Return the element associated with the directive [node], or `null` if the
+   * AST structure has not been resolved or if this directive could not be
+   * resolved.
+   */
+  Element elementDeclaredByDirective(Directive node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  ClassElement elementDeclaredByEnumDeclaration(EnumDeclaration node);
+
+  /**
+   * Return the element representing the parameter [node], or `null` if this
+   * parameter has not been resolved.
+   */
+  ParameterElement elementDeclaredByFormalParameter(FormalParameter node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  ExecutableElement elementDeclaredByFunctionDeclaration(
+      FunctionDeclaration node);
+
+  /**
+   * Return the element associated with the function expression [node], or
+   * `null` if the AST structure has not been resolved.
+   */
+  ExecutableElement elementDeclaredByFunctionExpression(
+      FunctionExpression node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  ExecutableElement elementDeclaredByMethodDeclaration(MethodDeclaration node);
+
+  /**
+   * Return the element associated with the declaration [node], or `null` if
+   * either this node corresponds to a list of declarations or if the AST
+   * structure has not been resolved.
+   */
+  VariableElement elementDeclaredByVariableDeclaration(
+      VariableDeclaration node);
+
+  /**
+   * Return the element associated with the annotation [node], or `null` if the
+   * AST structure has not been resolved or if this annotation could not be
+   * resolved.
+   */
+  Element elementForAnnotation(Annotation node);
+
+  /**
+   * Return the element representing the parameter being named by the
+   * expression [node], or `null` if the AST structure has not been resolved or
+   * if there is no parameter with the same name as this expression.
+   */
+  ParameterElement elementForNamedExpression(NamedExpression node);
+
+  /**
+   * Return a list containing the elements representing the parameters in the
+   * list [node]. The list will contain `null`s if the parameters in this list
+   * have not been resolved.
+   */
+  List<ParameterElement> parameterElementsForFormalParameterList(
+      FormalParameterList node);
+
+  /**
+   * Return the element associated with the function being invoked at [node]
+   * based on propagated type information, or `null` if the AST structure has
+   * not been resolved or the function could not be resolved.
+   */
+  ExecutableElement propagatedElementForFunctionExpressionInvocation(
+      FunctionExpressionInvocation node);
+
+  /**
+   * Return the element associated with the identifier [node] based on
+   * propagated type information, or `null` if the AST structure has not been
+   * resolved or if this identifier could not be resolved. One example of the
+   * latter case is an identifier that is not defined within the scope in which
+   * it appears.
+   */
+  Element propagatedElementForIdentifier(Identifier node);
+
+  /**
+   * Return the element associated with the expression [node] based on
+   * propagated types, or `null` if the AST structure has not been resolved, or
+   * there is no meaningful propagated element to return (e.g. because this is a
+   * non-compound assignment expression, or because the method referred to could
+   * not be resolved).
+   */
+  MethodElement propagatedElementForMethodReference(
+      MethodReferenceExpression node);
+
+  /**
+   * If the expression [node] is an argument to an invocation, and the AST
+   * structure has been resolved, and the function being invoked is known based
+   * on propagated type information, and [node] corresponds to one of the
+   * parameters of the function being invoked, then return the parameter element
+   * representing the parameter to which the value of [node] will be
+   * bound. Otherwise, return `null`.
+   */
+  ParameterElement propagatedParameterElementForExpression(Expression node);
+
+  /**
+   * Return the propagated type of the expression [node], or `null` if type
+   * propagation has not been performed on the AST structure.
+   */
+  DartType propagatedTypeForExpression(Expression node);
+
+  /**
+   * Return the element associated with the constructor referenced by [node]
+   * based on static type information, or `null` if the AST structure has not
+   * been resolved or if the constructor could not be resolved.
+   */
+  ConstructorElement staticElementForConstructorReference(
+      ConstructorReferenceNode node);
+
+  /**
+   * Return the element associated with the function being invoked at [node]
+   * based on static type information, or `null` if the AST structure has not
+   * been resolved or the function could not be resolved.
+   */
+  ExecutableElement staticElementForFunctionExpressionInvocation(
+      FunctionExpressionInvocation node);
+
+  /**
+   * Return the element associated with the identifier [node] based on static
+   * type information, or `null` if the AST structure has not been resolved or
+   * if this identifier could not be resolved. One example of the latter case is
+   * an identifier that is not defined within the scope in which it appears
+   */
+  Element staticElementForIdentifier(Identifier node);
+
+  /**
+   * Return the element associated with the expression [node] based on the
+   * static types, or `null` if the AST structure has not been resolved, or
+   * there is no meaningful static element to return (e.g. because this is a
+   * non-compound assignment expression, or because the method referred to could
+   * not be resolved).
+   */
+  MethodElement staticElementForMethodReference(MethodReferenceExpression node);
+
+  /**
+   * Return the function type of the invocation [node] based on the static type
+   * information, or `null` if the AST structure has not been resolved, or if
+   * the invoke could not be resolved.
+   *
+   * This will usually be a [FunctionType], but it can also be an
+   * [InterfaceType] with a `call` method, `dynamic`, `Function`, or a `@proxy`
+   * interface type that implements `Function`.
+   */
+  DartType staticInvokeTypeForInvocationExpression(InvocationExpression node);
+
+  /**
+   * If the expression [node] is an argument to an invocation, and the AST
+   * structure has been resolved, and the function being invoked is known based
+   * on static type information, and [node] corresponds to one of the parameters
+   * of the function being invoked, then return the parameter element
+   * representing the parameter to which the value of [node] will be
+   * bound. Otherwise, return `null`.
+   */
+  ParameterElement staticParameterElementForExpression(Expression node);
+
+  /**
+   * Return the static type of the expression [node], or `null` if the AST
+   * structure has not been resolved.
+   */
+  DartType staticTypeForExpression(Expression node);
+
+  /**
+   * Return the type being named by [node], or `null` if the AST structure has
+   * not been resolved.
+   */
+  DartType typeForTypeName(TypeName node);
+
+  /**
+   * Return the element associated with the uri of the directive [node], or
+   * `null` if the AST structure has not been resolved or if the URI could not
+   * be resolved. Examples of the latter case include a directive that contains
+   * an invalid URL or a URL that does not exist.
+   */
+  Element uriElementForDirective(UriBasedDirective node);
+}