Fixes for translator and DDA status files.

pkg/analyzer_experimental/lib/src/generated/ast.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 483 matching lines @@
    * Return an array containing the comment and annotations associated with this node, sorted in
    * lexical order.
    * @return the comment and annotations associated with this node in the order in which they
    * appeared in the original source
    */
   List<ASTNode> get sortedCommentAndAnnotations {
     List<ASTNode> childList = new List<ASTNode>();
     childList.add(_comment);
     childList.addAll(_metadata);
     List<ASTNode> children = new List.from(childList);
-    children.sort();
+    children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 /**
  * Instances of the class {@code Annotation} represent an annotation that can be associated with an
  * AST node.
  * <pre>
  * metadata ::=
  * annotation
  * annotation ::=
@@ skipping 264 matching lines @@
   NodeList<Expression> _arguments;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * An array containing the elements representing the parameters corresponding to each of the
    * arguments in this list, or {@code null} if the AST has not been resolved or if the function or
-   * method being invoked could not be determined. The array must be the same length as the number
-   * of arguments, but can contain {@code null} entries if a given argument does not correspond to a
-   * formal parameter.
+   * method being invoked could not be determined based on static type information. The array must
+   * be the same length as the number of arguments, but can contain {@code null} entries if a given
+   * argument does not correspond to a formal parameter.
    */
-  List<ParameterElement> _correspondingParameters;
+  List<ParameterElement> _correspondingStaticParameters;
+
+  /**
+   * An array containing the elements representing the parameters corresponding to each of the
+   * arguments in this list, or {@code null} if the AST has not been resolved or if the function or
+   * method being invoked could not be determined based on propagated type information. The array
+   * must be the same length as the number of arguments, but can contain {@code null} entries if a
+   * given argument does not correspond to a formal parameter.
+   */
+  List<ParameterElement> _correspondingPropagatedParameters;
 
   /**
    * Initialize a newly created list of arguments.
    * @param leftParenthesis the left parenthesis
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
   ArgumentList.full(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
     this._arguments = new NodeList<Expression>(this);
     this._leftParenthesis = leftParenthesis;
@@ skipping 36 matching lines @@
    * Set the parameter elements corresponding to each of the arguments in this list to the given
    * array of parameters. The array of parameters must be the same length as the number of
    * arguments, but can contain {@code null} entries if a given argument does not correspond to a
    * formal parameter.
    * @param parameters the parameter elements corresponding to the arguments
    */
   void set correspondingParameters(List<ParameterElement> parameters) {
     if (parameters.length != _arguments.length) {
       throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
-    _correspondingParameters = parameters;
+    _correspondingPropagatedParameters = parameters;
   }
 
   /**
+   * Set the parameter elements corresponding to each of the arguments in this list to the given
+   * array of parameters. The array of parameters must be the same length as the number of
+   * arguments, but can contain {@code null} entries if a given argument does not correspond to a
+   * formal parameter.
+   * @param parameters the parameter elements corresponding to the arguments
+   */
+  void set correspondingStaticParameters(List<ParameterElement> parameters) {
+    if (parameters.length != _arguments.length) {
+      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
+    }
+    _correspondingStaticParameters = parameters;
+  }
+
+  /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
   void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
 
   /**
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
-   * the function being invoked is known, and the expression corresponds to one of the parameters of
-   * the function being invoked, then return the parameter element representing the parameter to
-   * which the value of the given expression will be bound. Otherwise, return {@code null}.
+   * the function being invoked is known based on propagated type information, and the expression
+   * corresponds to one of the parameters of the function being invoked, then return the parameter
+   * element representing the parameter to which the value of the given expression will be bound.
+   * Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    * will be bound
    */
-  ParameterElement getParameterElementFor(Expression expression) {
-    if (_correspondingParameters == null) {
+  ParameterElement getPropagatedParameterElementFor(Expression expression) {
+    if (_correspondingPropagatedParameters == null) {
       return null;
     }
     int index = _arguments.indexOf(expression);
     if (index < 0) {
       return null;
     }
-    return _correspondingParameters[index];
+    return _correspondingPropagatedParameters[index];
+  }
+
+  /**
+   * If the given expression is a child of this list, and the AST structure has been resolved, and
+   * the function being invoked is known based on static type information, and the expression
+   * corresponds to one of the parameters of the function being invoked, then return the parameter
+   * element representing the parameter to which the value of the given expression will be bound.
+   * Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * @param expression the expression corresponding to the parameter to be returned
+   * @return the parameter element representing the parameter to which the value of the expression
+   * will be bound
+   */
+  ParameterElement getStaticParameterElementFor(Expression expression) {
+    if (_correspondingStaticParameters == null) {
+      return null;
+    }
+    int index = _arguments.indexOf(expression);
+    if (index < 0) {
+      return null;
+    }
+    return _correspondingStaticParameters[index];
   }
 }
 /**
  * Instances of the class {@code AsExpression} represent an 'as' expression.
  * <pre>
  * asExpression ::={@link Expression expression} 'as' {@link TypeName type}</pre>
  * @coverage dart.engine.ast
  */
 class AsExpression extends Expression {
 
@@ skipping 492 matching lines @@
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 
   /**
-   * Return the parameter element representing the parameter to which the value of the right operand
-   * will be bound. May be {@code null}.
+   * If the AST structure has been resolved, and the function being invoked is known based on
+   * propagated type information, then return the parameter element representing the parameter to
+   * which the value of the right operand will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
-  ParameterElement get parameterElementForRightOperand {
+  ParameterElement get propagatedParameterElementForRightOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters2 = _propagatedElement.parameters;
     if (parameters2.length < 1) {
       return null;
     }
     return parameters2[0];
   }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on static
+   * type information, then return the parameter element representing the parameter to which the
+   * value of the right operand will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * @return the parameter element representing the parameter to which the value of the right
+   * operand will be bound
+   */
+  ParameterElement get staticParameterElementForRightOperand {
+    if (_staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters2 = _staticElement.parameters;
+    if (parameters2.length < 1) {
+      return null;
+    }
+    return parameters2[0];
+  }
 }
 /**
  * Instances of the class {@code Block} represent a sequence of statements.
  * <pre>
  * block ::=
  * '{' statement* '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class Block extends Statement {
@@ skipping 3267 matching lines @@
   Type2 _staticType;
 
   /**
    * The propagated type of this expression, or {@code null} if type propagation has not been
    * performed on the AST structure.
    */
   Type2 _propagatedType;
 
   /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
-   * and the function being invoked is known, and this expression corresponds to one of the
-   * parameters of the function being invoked, then return the parameter element representing the
-   * parameter to which the value of this expression will be bound. Otherwise, return {@code null}.
+   * and the function being invoked is known based on propagated type information, and this
+   * expression corresponds to one of the parameters of the function being invoked, then return the
+   * parameter element representing the parameter to which the value of this expression will be
+   * bound. Otherwise, return {@code null}.
    * @return the parameter element representing the parameter to which the value of this expression
    * will be bound
    */
   ParameterElement get parameterElement {
     ASTNode parent2 = parent;
     if (parent2 is ArgumentList) {
-      return ((parent2 as ArgumentList)).getParameterElementFor(this);
-    }
-    if (parent2 is IndexExpression) {
+      return ((parent2 as ArgumentList)).getPropagatedParameterElementFor(this);
+    } else if (parent2 is IndexExpression) {
       IndexExpression indexExpression = parent2 as IndexExpression;
       if (identical(indexExpression.index, this)) {
-        return indexExpression.parameterElementForIndex;
+        return indexExpression.propagatedParameterElementForIndex;
       }
-    }
-    if (parent2 is BinaryExpression) {
+    } else if (parent2 is BinaryExpression) {
       BinaryExpression binaryExpression = parent2 as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
-        return binaryExpression.parameterElementForRightOperand;
+        return binaryExpression.propagatedParameterElementForRightOperand;
       }
+    } else if (parent2 is PrefixExpression) {
+      return ((parent2 as PrefixExpression)).propagatedParameterElementForOperand;
+    } else if (parent2 is PostfixExpression) {
+      return ((parent2 as PostfixExpression)).propagatedParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * Return the propagated type of this expression, or {@code null} if type propagation has not been
    * performed on the AST structure.
    * @return the propagated type of this expression
    */
   Type2 get propagatedType => _propagatedType;
 
   /**
+   * If this expression 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 this expression
+   * corresponds to one of the parameters of the function being invoked, then return the parameter
+   * element representing the parameter to which the value of this expression will be bound.
+   * Otherwise, return {@code null}.
+   * @return the parameter element representing the parameter to which the value of this expression
+   * will be bound
+   */
+  ParameterElement get staticParameterElement {
+    ASTNode parent2 = parent;
+    if (parent2 is ArgumentList) {
+      return ((parent2 as ArgumentList)).getStaticParameterElementFor(this);
+    } else if (parent2 is IndexExpression) {
+      IndexExpression indexExpression = parent2 as IndexExpression;
+      if (identical(indexExpression.index, this)) {
+        return indexExpression.staticParameterElementForIndex;
+      }
+    } else if (parent2 is BinaryExpression) {
+      BinaryExpression binaryExpression = parent2 as BinaryExpression;
+      if (identical(binaryExpression.rightOperand, this)) {
+        return binaryExpression.staticParameterElementForRightOperand;
+      }
+    } else if (parent2 is PrefixExpression) {
+      return ((parent2 as PrefixExpression)).staticParameterElementForOperand;
+    } else if (parent2 is PostfixExpression) {
+      return ((parent2 as PostfixExpression)).staticParameterElementForOperand;
+    }
+    return null;
+  }
+
+  /**
    * Return the static type of this expression, or {@code null} if the AST structure has not been
    * resolved.
    * @return the static type of this expression
    */
   Type2 get staticType => _staticType;
 
   /**
    * Return {@code true} if this expression is syntactically valid for the LHS of an{@link AssignmentExpression assignment expression}.
    * @return {@code true} if this expression matches the {@code assignableExpression} production
    */
@@ skipping 2526 matching lines @@
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 
   /**
-   * Return the parameter element representing the parameter to which the value of the index
-   * expression will be bound. May be {@code null}.
+   * If the AST structure has been resolved, and the function being invoked is known based on
+   * propagated type information, then return the parameter element representing the parameter to
+   * which the value of the index expression will be bound. Otherwise, return {@code null}.
    * <p>
    * This method is only intended to be used by {@link Expression#getParameterElement()}.
    * @return the parameter element representing the parameter to which the value of the index
    * expression will be bound
    */
-  ParameterElement get parameterElementForIndex {
+  ParameterElement get propagatedParameterElementForIndex {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters2 = _propagatedElement.parameters;
     if (parameters2.length < 1) {
       return null;
     }
     return parameters2[0];
   }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on static
+   * type information, then return the parameter element representing the parameter to which the
+   * value of the index expression will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * @return the parameter element representing the parameter to which the value of the index
+   * expression will be bound
+   */
+  ParameterElement get staticParameterElementForIndex {
+    if (_staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters2 = _staticElement.parameters;
+    if (parameters2.length < 1) {
+      return null;
+    }
+    return parameters2[0];
+  }
 }
 /**
  * Instances of the class {@code InstanceCreationExpression} represent an instance creation
  * expression.
  * <pre>
  * newExpression ::=
  * ('new' | 'const') {@link TypeName type} ('.' {@link SimpleIdentifier identifier})? {@link ArgumentList argumentList}</pre>
  * @coverage dart.engine.ast
  */
 class InstanceCreationExpression extends Expression {
@@ skipping 1898 matching lines @@
    * Return an array containing the comment and annotations associated with this parameter, sorted
    * in lexical order.
    * @return the comment and annotations associated with this parameter in the order in which they
    * appeared in the original source
    */
   List<ASTNode> get sortedCommentAndAnnotations {
     List<ASTNode> childList = new List<ASTNode>();
     childList.add(_comment);
     childList.addAll(_metadata);
     List<ASTNode> children = new List.from(childList);
-    children.sort();
+    children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 /**
  * Instances of the class {@code NullLiteral} represent a null literal expression.
  * <pre>
  * nullLiteral ::=
  * 'null'
  * </pre>
  * @coverage dart.engine.ast
@@ skipping 433 matching lines @@
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    * @param element the element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on
+   * propagated type information, then return the parameter element representing the parameter to
+   * which the value of the operand will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * @return the parameter element representing the parameter to which the value of the right
+   * operand will be bound
+   */
+  ParameterElement get propagatedParameterElementForOperand {
+    if (_propagatedElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters2 = _propagatedElement.parameters;
+    if (parameters2.length < 1) {
+      return null;
+    }
+    return parameters2[0];
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on static
+   * type information, then return the parameter element representing the parameter to which the
+   * value of the operand will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * @return the parameter element representing the parameter to which the value of the right
+   * operand will be bound
+   */
+  ParameterElement get staticParameterElementForOperand {
+    if (_staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters2 = _staticElement.parameters;
+    if (parameters2.length < 1) {
+      return null;
+    }
+    return parameters2[0];
+  }
 }
 /**
  * Instances of the class {@code PrefixExpression} represent a prefix unary expression.
  * <pre>
  * prefixExpression ::={@link Token operator} {@link Expression operand}</pre>
  * @coverage dart.engine.ast
  */
 class PrefixExpression extends Expression {
 
   /**
@@ skipping 95 matching lines @@
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on
+   * propagated type information, then return the parameter element representing the parameter to
+   * which the value of the operand will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * @return the parameter element representing the parameter to which the value of the right
+   * operand will be bound
+   */
+  ParameterElement get propagatedParameterElementForOperand {
+    if (_propagatedElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters2 = _propagatedElement.parameters;
+    if (parameters2.length < 1) {
+      return null;
+    }
+    return parameters2[0];
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on static
+   * type information, then return the parameter element representing the parameter to which the
+   * value of the operand will be bound. Otherwise, return {@code null}.
+   * <p>
+   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * @return the parameter element representing the parameter to which the value of the right
+   * operand will be bound
+   */
+  ParameterElement get staticParameterElementForOperand {
+    if (_staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters2 = _staticElement.parameters;
+    if (parameters2.length < 1) {
+      return null;
+    }
+    return parameters2[0];
+  }
 }
 /**
  * Instances of the class {@code PrefixedIdentifier} represent either an identifier that is prefixed
  * or an access to an object property where the target of the property access is a simple
  * identifier.
  * <pre>
  * prefixedIdentifier ::={@link SimpleIdentifier prefix} '.' {@link SimpleIdentifier identifier}</pre>
  * @coverage dart.engine.ast
  */
 class PrefixedIdentifier extends Identifier {
@@ skipping 5449 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }