New Analysis Engine translation.

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;
@@ skipping 266 matching lines @@
   R visitNamedExpression(NamedExpression node);
   R visitNullLiteral(NullLiteral node);
   R visitParenthesizedExpression(ParenthesizedExpression node);
   R visitPartDirective(PartDirective node);
   R visitPartOfDirective(PartOfDirective node);
   R visitPostfixExpression(PostfixExpression node);
   R visitPrefixedIdentifier(PrefixedIdentifier node);
   R visitPrefixExpression(PrefixExpression node);
   R visitPropertyAccess(PropertyAccess node);
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node);
+  R visitRethrowExpression(RethrowExpression node);
   R visitReturnStatement(ReturnStatement node);
   R visitScriptTag(ScriptTag node);
   R visitShowCombinator(ShowCombinator node);
   R visitSimpleFormalParameter(SimpleFormalParameter node);
   R visitSimpleIdentifier(SimpleIdentifier node);
   R visitSimpleStringLiteral(SimpleStringLiteral node);
   R visitStringInterpolation(StringInterpolation node);
   R visitSuperConstructorInvocation(SuperConstructorInvocation node);
   R visitSuperExpression(SuperExpression node);
   R visitSwitchCase(SwitchCase node);
@@ skipping 107 matching lines @@
    * not have a documentation comment associated with it.
    * @return the documentation comment associated with this node
    */
   Comment get documentationComment => _comment;
   /**
    * Return the annotations associated with this node.
    * @return the annotations associated with this node
    */
   NodeList<Annotation> get metadata => _metadata;
   /**
-   * Set the documentation comment associated with this node to the given comment
+   * Set the documentation comment associated with this node to the given comment.
    * @param comment the documentation comment to be associated with this node
    */
   void set documentationComment(Comment comment2) {
     this._comment = becomeParentOf(comment2);
   }
+  /**
+   * Set the metadata associated with this node to the given metadata.
+   * @param metadata the metadata to be associated with this node
+   */
+  void set metadata(List<Annotation> metadata2) {
+    this._metadata.clear();
+    this._metadata.addAll(metadata2);
+  }
   void visitChildren(ASTVisitor<Object> visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
@@ skipping 7258 matching lines @@
    */
   NamedExpression({Label name, Expression expression}) : this.full(name, expression);
   accept(ASTVisitor visitor) => visitor.visitNamedExpression(this);
   Token get beginToken => _name.beginToken;
   /**
    * Return the element representing the parameter being named by this expression, or {@code null}if the AST structure has not been resolved or if there is no parameter with the same name as
    * this expression.
    * @return the element representing the parameter being named by this expression
    */
   ParameterElement get element {
-    Element element20 = _name.label.element;
-    if (element20 is ParameterElement) {
-      return element20 as ParameterElement;
+    Element element22 = _name.label.element;
+    if (element22 is ParameterElement) {
+      return element22 as ParameterElement;
     }
     return null;
   }
   Token get endToken => _expression.endToken;
   /**
    * Return the expression with which the name is associated.
    * @return the expression with which the name is associated
    */
   Expression get expression => _expression;
   /**
@@ skipping 1001 matching lines @@
    */
   void set period(Token period11) {
     this._period = period11;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
+ * Instances of the class {@code RethrowExpression} represent a rethrow expression.
+ * <pre>
+ * rethrowExpression ::=
+ * 'rethrow'
+ * </pre>
+ * @coverage dart.engine.ast
+ */
+class RethrowExpression extends Expression {
+  /**
+   * The token representing the 'rethrow' keyword.
+   */
+  Token _keyword;
+  /**
+   * Initialize a newly created rethrow expression.
+   * @param keyword the token representing the 'rethrow' keyword
+   */
+  RethrowExpression.full(Token keyword) {
+    this._keyword = keyword;
+  }
+  /**
+   * Initialize a newly created rethrow expression.
+   * @param keyword the token representing the 'rethrow' keyword
+   */
+  RethrowExpression({Token keyword}) : this.full(keyword);
+  accept(ASTVisitor visitor) => visitor.visitRethrowExpression(this);
+  Token get beginToken => _keyword;
+  Token get endToken => _keyword;
+  /**
+   * Return the token representing the 'rethrow' keyword.
+   * @return the token representing the 'rethrow' keyword
+   */
+  Token get keyword => _keyword;
+  /**
+   * Set the token representing the 'rethrow' keyword to the given token.
+   * @param keyword the token representing the 'rethrow' keyword
+   */
+  void set keyword(Token keyword15) {
+    this._keyword = keyword15;
+  }
+  void visitChildren(ASTVisitor<Object> visitor) {
+  }
+}
+/**
  * Instances of the class {@code ReturnStatement} represent a return statement.
  * <pre>
  * returnStatement ::=
  * 'return' {@link Expression expression}? ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ReturnStatement extends Statement {
   /**
    * The token representing the 'return' keyword.
@@ skipping 49 matching lines @@
    * Set the expression computing the value to be returned to the given expression.
    * @param expression the expression computing the value to be returned
    */
   void set expression(Expression expression10) {
     this._expression = becomeParentOf(expression10);
   }
   /**
    * Set the token representing the 'return' keyword to the given token.
    * @param keyword the token representing the 'return' keyword
    */
-  void set keyword(Token keyword15) {
-    this._keyword = keyword15;
+  void set keyword(Token keyword16) {
+    this._keyword = keyword16;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon15) {
     this._semicolon = semicolon15;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
@@ skipping 142 matching lines @@
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword16) {
-    this._keyword = keyword16;
+  void set keyword(Token keyword17) {
+    this._keyword = keyword17;
   }
   /**
    * Set the name of the declared type of the parameter to the given type name.
    * @param typeName the name of the declared type of the parameter
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 409 matching lines @@
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
   void set element(ConstructorElement element17) {
     this._element = element17;
   }
   /**
    * Set the token for the 'super' keyword to the given token.
    * @param keyword the token for the 'super' keyword
    */
-  void set keyword(Token keyword17) {
-    this._keyword = keyword17;
+  void set keyword(Token keyword18) {
+    this._keyword = keyword18;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
   void set period(Token period12) {
     this._period = period12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
@@ skipping 31 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword(Token keyword18) {
-    this._keyword = keyword18;
+  void set keyword(Token keyword19) {
+    this._keyword = keyword19;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code SwitchCase} represent the case in a switch statement.
  * <pre>
  * switchCase ::={@link SimpleIdentifier label}* 'case' {@link Expression expression} ':' {@link Statement statement}</pre>
  * @coverage dart.engine.ast
  */
@@ skipping 157 matching lines @@
    * Set the colon separating the keyword or the expression from the statements to the given token.
    * @param colon the colon separating the keyword or the expression from the statements
    */
   void set colon(Token colon4) {
     this._colon = colon4;
   }
   /**
    * Set the token representing the 'case' or 'default' keyword to the given token.
    * @param keyword the token representing the 'case' or 'default' keyword
    */
-  void set keyword(Token keyword19) {
-    this._keyword = keyword19;
+  void set keyword(Token keyword20) {
+    this._keyword = keyword20;
   }
 }
 /**
  * Instances of the class {@code SwitchStatement} represent a switch statement.
  * <pre>
  * switchStatement ::=
  * 'switch' '(' {@link Expression expression} ')' '{' {@link SwitchCase switchCase}* {@link SwitchDefault defaultCase}? '}'
  * </pre>
  * @coverage dart.engine.ast
  */
@@ skipping 100 matching lines @@
    * expression.
    * @param expression the expression used to determine which of the switch members will be selected
    */
   void set expression(Expression expression12) {
     this._expression = becomeParentOf(expression12);
   }
   /**
    * Set the token representing the 'switch' keyword to the given token.
    * @param keyword the token representing the 'switch' keyword
    */
-  void set keyword(Token keyword20) {
-    this._keyword = keyword20;
+  void set keyword(Token keyword21) {
+    this._keyword = keyword21;
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
   void set leftBracket(Token leftBracket7) {
     this._leftBracket = leftBracket7;
   }
   /**
    * Set the left parenthesis to the given token.
@@ skipping 51 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword(Token keyword21) {
-    this._keyword = keyword21;
+  void set keyword(Token keyword22) {
+    this._keyword = keyword22;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ThrowExpression} represent a throw expression.
  * <pre>
  * throwExpression ::=
- * 'throw' {@link Expression expression}? ';'
- * </pre>
+ * 'throw' {@link Expression expression}</pre>
  * @coverage dart.engine.ast
  */
 class ThrowExpression extends Expression {
   /**
    * The token representing the 'throw' keyword.
    */
   Token _keyword;
   /**
-   * The expression computing the exception to be thrown, or {@code null} if the current exception
-   * is to be re-thrown. (The latter case can only occur if the throw statement is inside a catch
-   * clause.)
+   * The expression computing the exception to be thrown.
    */
   Expression _expression;
   /**
    * Initialize a newly created throw expression.
    * @param keyword the token representing the 'throw' keyword
    * @param expression the expression computing the exception to be thrown
    */
   ThrowExpression.full(Token keyword, Expression expression) {
     this._keyword = keyword;
     this._expression = becomeParentOf(expression);
   }
   /**
    * Initialize a newly created throw expression.
    * @param keyword the token representing the 'throw' keyword
    * @param expression the expression computing the exception to be thrown
    */
   ThrowExpression({Token keyword, Expression expression}) : this.full(keyword, expression);
   accept(ASTVisitor visitor) => visitor.visitThrowExpression(this);
   Token get beginToken => _keyword;
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
     return _keyword;
   }
   /**
-   * Return the expression computing the exception to be thrown, or {@code null} if the current
-   * exception is to be re-thrown. (The latter case can only occur if the throw statement is inside
-   * a catch clause.)
+   * Return the expression computing the exception to be thrown.
    * @return the expression computing the exception to be thrown
    */
   Expression get expression => _expression;
   /**
    * Return the token representing the 'throw' keyword.
    * @return the token representing the 'throw' keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the expression computing the exception to be thrown to the given expression.
    * @param expression the expression computing the exception to be thrown
    */
   void set expression(Expression expression13) {
     this._expression = becomeParentOf(expression13);
   }
   /**
    * Set the token representing the 'throw' keyword to the given token.
    * @param keyword the token representing the 'throw' keyword
    */
-  void set keyword(Token keyword22) {
-    this._keyword = keyword22;
+  void set keyword(Token keyword23) {
+    this._keyword = keyword23;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code TopLevelVariableDeclaration} represent the declaration of one or
  * more top-level variables of the same type.
  * <pre>
  * topLevelVariableDeclaration ::=
@@ skipping 240 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'typedef' keyword to the given token.
    * @param keyword the token representing the 'typedef' keyword
    */
-  void set keyword(Token keyword23) {
-    this._keyword = keyword23;
+  void set keyword(Token keyword24) {
+    this._keyword = keyword24;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
   void set semicolon(Token semicolon17) {
     this._semicolon = semicolon17;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
@@ skipping 234 matching lines @@
    * Set the name of the upper bound for legal arguments to the given type name.
    * @param typeName the name of the upper bound for legal arguments
    */
   void set bound(TypeName typeName) {
     _bound = becomeParentOf(typeName);
   }
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
-  void set keyword(Token keyword24) {
-    this._keyword = keyword24;
+  void set keyword(Token keyword25) {
+    this._keyword = keyword25;
   }
   /**
    * Set the name of the type parameter to the given identifier.
    * @param identifier the name of the type parameter
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 295 matching lines @@
  * <pre>
  * variableDeclarationList ::=
  * finalConstVarOrType {@link VariableDeclaration variableDeclaration} (',' {@link VariableDeclaration variableDeclaration})
  * finalConstVarOrType ::=
  * | 'final' {@link TypeName type}?
  * | 'const' {@link TypeName type}?
  * | 'var'
  * | {@link TypeName type}</pre>
  * @coverage dart.engine.ast
  */
-class VariableDeclarationList extends ASTNode {
+class VariableDeclarationList extends AnnotatedNode {
   /**
    * The token representing the 'final', 'const' or 'var' keyword, or {@code null} if no keyword was
    * included.
    */
   Token _keyword;
   /**
    * The type of the variables being declared, or {@code null} if no type was provided.
    */
   TypeName _type;
   /**
    * A list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> _variables;
   /**
    * Initialize a newly created variable declaration list.
+   * @param comment the documentation comment associated with this declaration list
+   * @param metadata the annotations associated with this declaration list
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    * @param type the type of the variables being declared
    * @param variables a list containing the individual variables being declared
    */
-  VariableDeclarationList.full(Token keyword, TypeName type, List<VariableDeclaration> variables) {
+  VariableDeclarationList.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, List<VariableDeclaration> variables) : super.full(comment, metadata) {
     this._variables = new NodeList<VariableDeclaration>(this);
     this._keyword = keyword;
     this._type = becomeParentOf(type);
     this._variables.addAll(variables);
   }
   /**
    * Initialize a newly created variable declaration list.
+   * @param comment the documentation comment associated with this declaration list
+   * @param metadata the annotations associated with this declaration list
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    * @param type the type of the variables being declared
    * @param variables a list containing the individual variables being declared
    */
-  VariableDeclarationList({Token keyword, TypeName type, List<VariableDeclaration> variables}) : this.full(keyword, type, variables);
+  VariableDeclarationList({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, List<VariableDeclaration> variables}) : this.full(comment, metadata, keyword, type, variables);
   accept(ASTVisitor visitor) => visitor.visitVariableDeclarationList(this);
-  Token get beginToken {
-    if (_keyword != null) {
-      return _keyword;
-    } else if (_type != null) {
-      return _type.beginToken;
-    }
-    return _variables.beginToken;
-  }
   Token get endToken => _variables.endToken;
   /**
    * Return the token representing the 'final', 'const' or 'var' keyword, or {@code null} if no
    * keyword was included.
    * @return the token representing the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the type of the variables being declared, or {@code null} if no type was provided.
    * @return the type of the variables being declared
@@ skipping 13 matching lines @@
    * Return {@code true} if the variables in this list were declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return {@code false} even though
    * they are implicitly final.
    * @return {@code true} if the variables in this list were declared with the 'final' modifier
    */
   bool isFinal() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword25) {
-    this._keyword = keyword25;
+  void set keyword(Token keyword26) {
+    this._keyword = keyword26;
   }
   /**
    * Set the type of the variables being declared to the given type name.
    * @param typeName the type of the variables being declared
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
+  Token get firstTokenAfterCommentAndMetadata {
+    if (_keyword != null) {
+      return _keyword;
+    } else if (_type != null) {
+      return _type.beginToken;
+    }
+    return _variables.beginToken;
+  }
 }
 /**
  * Instances of the class {@code VariableDeclarationStatement} represent a list of variables that
  * are being declared in a context where a statement is required.
  * <pre>
  * variableDeclarationStatement ::={@link VariableDeclarationList variableList} ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class VariableDeclarationStatement extends Statement {
@@ skipping 143 matching lines @@
    * expression.
    * @param expression the expression used to determine whether to execute the body of the loop
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'while' keyword to the given token.
    * @param keyword the token representing the 'while' keyword
    */
-  void set keyword(Token keyword26) {
-    this._keyword = keyword26;
+  void set keyword(Token keyword27) {
+    this._keyword = keyword27;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
   void set leftParenthesis(Token leftParenthesis7) {
     this._leftParenthesis = leftParenthesis7;
   }
   /**
    * Set the right parenthesis to the given token.
@@ skipping 385 matching lines @@
    * Clients should use {@link #locate(ASTNode)}.
    */
   ElementLocator() {
   }
 }
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
   Element visitBinaryExpression(BinaryExpression node) => node.element;
+  Element visitClassDeclaration(ClassDeclaration node) => node.element;
+  Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
   Element visitIdentifier(Identifier node) => node.element;
   Element visitImportDirective(ImportDirective node) => node.element;
   Element visitIndexExpression(IndexExpression node) => node.element;
   Element visitLibraryDirective(LibraryDirective node) => node.element;
+  Element visitMethodDeclaration(MethodDeclaration node) => node.element;
   Element visitPostfixExpression(PostfixExpression node) => node.element;
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.element;
   Element visitPrefixExpression(PrefixExpression node) => node.element;
   Element visitStringLiteral(StringLiteral node) {
     ASTNode parent12 = node.parent;
     if (parent12 is UriBasedDirective) {
       return ((parent12 as UriBasedDirective)).element;
     }
     return null;
   }
+  Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 /**
  * Instances of the class {@code GeneralizingASTVisitor} implement an AST visitor that will
  * recursively visit all of the nodes in an AST structure (like instances of the class{@link RecursiveASTVisitor}). In addition, when a node of a specific type is visited not only
  * will the visit method for that specific type of node be invoked, but additional methods for the
  * superclasses of that node will also be invoked. For example, using an instance of this class to
  * visit a {@link Block} will cause the method {@link #visitBlock(Block)} to be invoked but will
  * also cause the methods {@link #visitStatement(Statement)} and {@link #visitNode(ASTNode)} to be
  * subsequently invoked. This allows visitors to be written that visit all statements without
  * needing to override the visit method for each of the specific subclasses of {@link Statement}.
@@ skipping 91 matching lines @@
   R visitNormalFormalParameter(NormalFormalParameter node) => visitFormalParameter(node);
   R visitNullLiteral(NullLiteral node) => visitLiteral(node);
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitExpression(node);
   R visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
   R visitPartOfDirective(PartOfDirective node) => visitDirective(node);
   R visitPostfixExpression(PostfixExpression node) => visitExpression(node);
   R visitPrefixedIdentifier(PrefixedIdentifier node) => visitIdentifier(node);
   R visitPrefixExpression(PrefixExpression node) => visitExpression(node);
   R visitPropertyAccess(PropertyAccess node) => visitExpression(node);
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => visitConstructorInitializer(node);
+  R visitRethrowExpression(RethrowExpression node) => visitExpression(node);
   R visitReturnStatement(ReturnStatement node) => visitStatement(node);
   R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
   R visitShowCombinator(ShowCombinator node) => visitCombinator(node);
   R visitSimpleFormalParameter(SimpleFormalParameter node) => visitNormalFormalParameter(node);
   R visitSimpleIdentifier(SimpleIdentifier node) => visitIdentifier(node);
   R visitSimpleStringLiteral(SimpleStringLiteral node) => visitStringLiteral(node);
   R visitStatement(Statement node) => visitNode(node);
   R visitStringInterpolation(StringInterpolation node) => visitStringLiteral(node);
   R visitStringLiteral(StringLiteral node) => visitLiteral(node);
   R visitSuperConstructorInvocation(SuperConstructorInvocation node) => visitConstructorInitializer(node);
@@ skipping 39 matching lines @@
    * The element that was found that corresponds to the given source range, or {@code null} if there
    * is no such element.
    */
   ASTNode _foundNode;
   /**
    * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
    * the node within an AST structure that corresponds to the given offset in the source.
    * @param offset the offset used to identify the node
    */
   NodeLocator.con1(int offset) {
-    _jtd_constructor_118_impl(offset);
+    _jtd_constructor_119_impl(offset);
   }
-  _jtd_constructor_118_impl(int offset) {
-    _jtd_constructor_119_impl(offset, offset);
+  _jtd_constructor_119_impl(int offset) {
+    _jtd_constructor_120_impl(offset, offset);
   }
   /**
    * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
    * the node within an AST structure that corresponds to the given range of characters in the
    * source.
    * @param start the start offset of the range used to identify the node
    * @param end the end offset of the range used to identify the node
    */
   NodeLocator.con2(int start, int end) {
-    _jtd_constructor_119_impl(start, end);
+    _jtd_constructor_120_impl(start, end);
   }
-  _jtd_constructor_119_impl(int start, int end) {
+  _jtd_constructor_120_impl(int start, int end) {
     this._startOffset = start;
     this._endOffset = end;
   }
   /**
    * Return the node that was found that corresponds to the given source range, or {@code null} if
    * there is no such node.
    * @return the node that was found
    */
   ASTNode get foundNode => _foundNode;
   /**
    * Search within the given AST node for an identifier representing a {@link DartElement Dart
    * element} in the specified source range. Return the element that was found, or {@code null} if
    * no element was found.
    * @param node the AST node within which to search
    * @return the element that was found
    */
   ASTNode searchWithin(ASTNode node) {
     try {
       node.accept(this);
     } on NodeLocator_NodeFoundException catch (exception) {
-    } on JavaException catch (exception) {
+    } catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Unable to locate element at offset (${_startOffset} - ${_endOffset})", exception);
       return null;
     }
     return _foundNode;
   }
   Object visitNode(ASTNode node) {
     try {
       node.visitChildren(this);
     } on NodeLocator_NodeFoundException catch (exception) {
       throw exception;
-    } on JavaException catch (exception) {
+    } catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Exception caught while traversing an AST structure.", exception);
     }
     int start = node.offset;
     int end = start + node.length;
     if (start <= _startOffset && _endOffset <= end) {
       _foundNode = node;
       throw new NodeLocator_NodeFoundException();
     }
     return null;
   }
@@ skipping 305 matching lines @@
     return null;
   }
   R visitPropertyAccess(PropertyAccess node) {
     node.visitChildren(this);
     return null;
   }
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     node.visitChildren(this);
     return null;
   }
+  R visitRethrowExpression(RethrowExpression node) {
+    node.visitChildren(this);
+    return null;
+  }
   R visitReturnStatement(ReturnStatement node) {
     node.visitChildren(this);
     return null;
   }
   R visitScriptTag(ScriptTag node) {
     node.visitChildren(this);
     return null;
   }
   R visitShowCombinator(ShowCombinator node) {
     node.visitChildren(this);
@@ skipping 163 matching lines @@
   R visitNamedExpression(NamedExpression node) => null;
   R visitNullLiteral(NullLiteral node) => null;
   R visitParenthesizedExpression(ParenthesizedExpression node) => null;
   R visitPartDirective(PartDirective node) => null;
   R visitPartOfDirective(PartOfDirective node) => null;
   R visitPostfixExpression(PostfixExpression node) => null;
   R visitPrefixedIdentifier(PrefixedIdentifier node) => null;
   R visitPrefixExpression(PrefixExpression node) => null;
   R visitPropertyAccess(PropertyAccess node) => null;
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => null;
+  R visitRethrowExpression(RethrowExpression node) => null;
   R visitReturnStatement(ReturnStatement node) => null;
   R visitScriptTag(ScriptTag node) => null;
   R visitShowCombinator(ShowCombinator node) => null;
   R visitSimpleFormalParameter(SimpleFormalParameter node) => null;
   R visitSimpleIdentifier(SimpleIdentifier node) => null;
   R visitSimpleStringLiteral(SimpleStringLiteral node) => null;
   R visitStringInterpolation(StringInterpolation node) => null;
   R visitSuperConstructorInvocation(SuperConstructorInvocation node) => null;
   R visitSuperExpression(SuperExpression node) => null;
   R visitSwitchCase(SwitchCase node) => null;
@@ skipping 557 matching lines @@
     }
     visit(node.propertyName);
     return null;
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _writer.print("this");
     visit3(".", node.constructorName);
     visit(node.argumentList);
     return null;
   }
+  Object visitRethrowExpression(RethrowExpression node) {
+    _writer.print("rethrow");
+    return null;
+  }
   Object visitReturnStatement(ReturnStatement node) {
     Expression expression14 = node.expression;
     if (expression14 == null) {
       _writer.print("return;");
     } else {
       _writer.print("return ");
       expression14.accept(this);
       _writer.print(";");
     }
     return null;
@@ skipping 305 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;
   }
 }