New analyzer snapshot.

pkg/analyzer/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 'source.dart' show LineInfo;
 import 'scanner.dart';
@@ skipping 46 matching lines @@
    * there is no enclosing node of the given class.
    *
    * @param nodeClass the class of the node to be returned
    * @return the node of the given type that encloses this node
    */
   ASTNode getAncestor(Type enclosingClass) {
     ASTNode node = this;
     while (node != null && !isInstanceOf(node, enclosingClass)) {
       node = node.parent;
     }
-    return node as ASTNode;
+    return node;
   }
 
   /**
    * Return the first token included in this node's source range.
    *
    * @return the first token included in this node's source range
    */
   Token get beginToken;
 
   /**
@@ skipping 2118 matching lines @@
     this._name = becomeParentOf(name);
     this.typeParameters = becomeParentOf(typeParameters);
     this._extendsClause = becomeParentOf(extendsClause);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
     this._members.addAll(members);
   }
 
   accept(ASTVisitor visitor) => visitor.visitClassDeclaration(this);
 
+  /**
+   * Return the constructor declared in the class with the given name.
+   *
+   * @param name the name of the constructor to find, `null` for default
+   * @return the found constructor or `null` if not found
+   */
+  ConstructorDeclaration getConstructor(String name) {
+    for (ClassMember classMember in _members) {
+      if (classMember is ConstructorDeclaration) {
+        ConstructorDeclaration constructor = classMember;
+        SimpleIdentifier constructorName = constructor.name;
+        if (name == null && constructorName == null) {
+          return constructor;
+        }
+        if (constructorName != null && constructorName.name == name) {
+          return constructor;
+        }
+      }
+    }
+    return null;
+  }
+
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
 
   Token get endToken => rightBracket;
 
   /**
    * Return the extends clause for this class, or `null` if the class does not extend any
    * other class.
    *
    * @return the extends clause for this class
    */
   ExtendsClause get extendsClause => _extendsClause;
 
   /**
    * Return the field declared in the class with the given name.
    *
    * @param name the name of the field to find
    * @return the found field or `null` if not found
    */
   VariableDeclaration getField(String name) {
     for (ClassMember classMember in _members) {
       if (classMember is FieldDeclaration) {
-        FieldDeclaration fieldDeclaration = classMember as FieldDeclaration;
+        FieldDeclaration fieldDeclaration = classMember;
         NodeList<VariableDeclaration> fields = fieldDeclaration.fields.variables;
         for (VariableDeclaration field in fields) {
           SimpleIdentifier fieldName = field.name;
           if (fieldName != null && name == fieldName.name) {
             return field;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Return the implements clause for the class, or `null` if the class does not implement any
    * interfaces.
    *
    * @return the implements clause for the class
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
    * Return the members defined by the class.
    *
    * @return the members defined by the class
    */
   NodeList<ClassMember> get members => _members;
 
   /**
+   * Return the method declared in the class with the given name.
+   *
+   * @param name the name of the method to find
+   * @return the found method or `null` if not found
+   */
+  MethodDeclaration getMethod(String name) {
+    for (ClassMember classMember in _members) {
+      if (classMember is MethodDeclaration) {
+        MethodDeclaration method = classMember;
+        SimpleIdentifier methodName = method.name;
+        if (methodName != null && name == methodName.name) {
+          return method;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return the name of the class being declared.
    *
    * @return the name of the class being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the with clause for the class, or `null` if the class does not have a with clause.
    *
    * @return the with clause for the class
@@ skipping 1931 matching lines @@
    * @param combinators the combinators used to control which names are exported
    * @param semicolon the semicolon terminating the directive
    */
   ExportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
 
   LibraryElement get uriElement {
     Element element = this.element;
     if (element is ExportElement) {
-      return (element as ExportElement).exportedLibrary;
+      return element.exportedLibrary;
     }
     return null;
   }
 
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 
@@ skipping 74 matching lines @@
    * 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 `null`.
    *
    * @return the parameter element representing the parameter to which the value of this expression
    *         will be bound
    */
   ParameterElement get propagatedParameterElement {
     ASTNode parent = this.parent;
     if (parent is ArgumentList) {
-      return (parent as ArgumentList).getPropagatedParameterElementFor(this);
+      return parent.getPropagatedParameterElementFor(this);
     } else if (parent is IndexExpression) {
-      IndexExpression indexExpression = parent as IndexExpression;
+      IndexExpression indexExpression = parent;
       if (identical(indexExpression.index, this)) {
         return indexExpression.propagatedParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
-      BinaryExpression binaryExpression = parent as BinaryExpression;
+      BinaryExpression binaryExpression = parent;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.propagatedParameterElementForRightOperand;
       }
     } else if (parent is AssignmentExpression) {
-      AssignmentExpression assignmentExpression = parent as AssignmentExpression;
+      AssignmentExpression assignmentExpression = parent;
       if (identical(assignmentExpression.rightHandSide, this)) {
         return assignmentExpression.propagatedParameterElementForRightHandSide;
       }
     } else if (parent is PrefixExpression) {
-      return (parent as PrefixExpression).propagatedParameterElementForOperand;
+      return parent.propagatedParameterElementForOperand;
     } else if (parent is PostfixExpression) {
-      return (parent as PostfixExpression).propagatedParameterElementForOperand;
+      return parent.propagatedParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * 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 `null`.
    *
    * @return the parameter element representing the parameter to which the value of this expression
    *         will be bound
    */
   ParameterElement get staticParameterElement {
     ASTNode parent = this.parent;
     if (parent is ArgumentList) {
-      return (parent as ArgumentList).getStaticParameterElementFor(this);
+      return parent.getStaticParameterElementFor(this);
     } else if (parent is IndexExpression) {
-      IndexExpression indexExpression = parent as IndexExpression;
+      IndexExpression indexExpression = parent;
       if (identical(indexExpression.index, this)) {
         return indexExpression.staticParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
-      BinaryExpression binaryExpression = parent as BinaryExpression;
+      BinaryExpression binaryExpression = parent;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.staticParameterElementForRightOperand;
       }
     } else if (parent is AssignmentExpression) {
-      AssignmentExpression assignmentExpression = parent as AssignmentExpression;
+      AssignmentExpression assignmentExpression = parent;
       if (identical(assignmentExpression.rightHandSide, this)) {
         return assignmentExpression.staticParameterElementForRightHandSide;
       }
     } else if (parent is PrefixExpression) {
-      return (parent as PrefixExpression).staticParameterElementForOperand;
+      return parent.staticParameterElementForOperand;
     } else if (parent is PostfixExpression) {
-      return (parent as PostfixExpression).staticParameterElementForOperand;
+      return parent.staticParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * Return `true` if this expression is syntactically valid for the LHS of an
    * [AssignmentExpression].
    *
    * @return `true` if this expression matches the `assignableExpression` production
    */
@@ skipping 1982 matching lines @@
         if (compare != 0) {
           return compare;
         }
       }
     }
     NodeList<Combinator> combinators1 = import1.combinators;
     List<String> allHides1 = new List<String>();
     List<String> allShows1 = new List<String>();
     for (Combinator combinator in combinators1) {
       if (combinator is HideCombinator) {
-        NodeList<SimpleIdentifier> hides = (combinator as HideCombinator).hiddenNames;
+        NodeList<SimpleIdentifier> hides = combinator.hiddenNames;
         for (SimpleIdentifier simpleIdentifier in hides) {
           allHides1.add(simpleIdentifier.name);
         }
       } else {
         NodeList<SimpleIdentifier> shows = (combinator as ShowCombinator).shownNames;
         for (SimpleIdentifier simpleIdentifier in shows) {
           allShows1.add(simpleIdentifier.name);
         }
       }
     }
     NodeList<Combinator> combinators2 = import2.combinators;
     List<String> allHides2 = new List<String>();
     List<String> allShows2 = new List<String>();
     for (Combinator combinator in combinators2) {
       if (combinator is HideCombinator) {
-        NodeList<SimpleIdentifier> hides = (combinator as HideCombinator).hiddenNames;
+        NodeList<SimpleIdentifier> hides = combinator.hiddenNames;
         for (SimpleIdentifier simpleIdentifier in hides) {
           allHides2.add(simpleIdentifier.name);
         }
       } else {
         NodeList<SimpleIdentifier> shows = (combinator as ShowCombinator).shownNames;
         for (SimpleIdentifier simpleIdentifier in shows) {
           allShows2.add(simpleIdentifier.name);
         }
       }
     }
@@ skipping 270 matching lines @@
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where the operator '[]' will be invoked
    */
   bool inGetterContext() {
     ASTNode parent = this.parent;
     if (parent is AssignmentExpression) {
-      AssignmentExpression assignment = parent as AssignmentExpression;
+      AssignmentExpression assignment = parent;
       if (identical(assignment.leftHandSide, this) && identical(assignment.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Return `true` if this expression is computing a left-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where the operator '[]=' will be
    *         invoked
    */
   bool inSetterContext() {
     ASTNode parent = this.parent;
     if (parent is PrefixExpression) {
-      return (parent as PrefixExpression).operator.type.isIncrementOperator;
+      return parent.operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
-      return identical((parent as AssignmentExpression).leftHandSide, this);
+      return identical(parent.leftHandSide, this);
     }
     return false;
   }
 
   bool get isAssignable => true;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a
    * [CascadeExpression].
@@ skipping 1486 matching lines @@
   /**
    * Return the element representing the parameter being named by this expression, or `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 element = _name.label.staticElement;
     if (element is ParameterElement) {
-      return element as ParameterElement;
+      return element;
     }
     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
@@ skipping 238 matching lines @@
    *
    * @return the documentation comment associated with this parameter
    */
   Comment get documentationComment => _comment;
 
   SimpleIdentifier get identifier => _identifier;
 
   ParameterKind get kind {
     ASTNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
-      return (parent as DefaultFormalParameter).kind;
+      return parent.kind;
     }
     return ParameterKind.REQUIRED;
   }
 
   /**
    * Return the annotations associated with this parameter.
    *
    * @return the annotations associated with this parameter
    */
   NodeList<Annotation> get metadata => _metadata;
@@ skipping 1318 matching lines @@
   Element get staticElement => _staticElement;
 
   /**
    * Return `true` if this identifier is the name being declared in a declaration.
    *
    * @return `true` if this identifier is the name being declared in a declaration
    */
   bool inDeclarationContext() {
     ASTNode parent = this.parent;
     if (parent is CatchClause) {
-      CatchClause clause = parent as CatchClause;
+      CatchClause clause = parent;
       return identical(this, clause.exceptionParameter) || identical(this, clause.stackTraceParameter);
     } else if (parent is ClassDeclaration) {
-      return identical(this, (parent as ClassDeclaration).name);
+      return identical(this, parent.name);
     } else if (parent is ClassTypeAlias) {
-      return identical(this, (parent as ClassTypeAlias).name);
+      return identical(this, parent.name);
     } else if (parent is ConstructorDeclaration) {
-      return identical(this, (parent as ConstructorDeclaration).name);
+      return identical(this, parent.name);
     } else if (parent is DeclaredIdentifier) {
-      return identical(this, (parent as DeclaredIdentifier).identifier);
+      return identical(this, parent.identifier);
     } else if (parent is FunctionDeclaration) {
-      return identical(this, (parent as FunctionDeclaration).name);
+      return identical(this, parent.name);
     } else if (parent is FunctionTypeAlias) {
-      return identical(this, (parent as FunctionTypeAlias).name);
+      return identical(this, parent.name);
     } else if (parent is Label) {
-      return identical(this, (parent as Label).label) && (parent.parent is LabeledStatement);
+      return identical(this, parent.label) && (parent.parent is LabeledStatement);
     } else if (parent is MethodDeclaration) {
-      return identical(this, (parent as MethodDeclaration).name);
+      return identical(this, parent.name);
     } else if (parent is FunctionTypedFormalParameter || parent is SimpleFormalParameter) {
       return identical(this, (parent as NormalFormalParameter).identifier);
     } else if (parent is TypeParameter) {
-      return identical(this, (parent as TypeParameter).name);
+      return identical(this, parent.name);
     } else if (parent is VariableDeclaration) {
-      return identical(this, (parent as VariableDeclaration).name);
+      return identical(this, parent.name);
     }
     return false;
   }
 
   /**
    * Return `true` if this expression is computing a right-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
@@ skipping 112 matching lines @@
    * identifier, or `null` if it is not appropriate.
    *
    * @param element the element to be associated with this identifier
    * @return the element to be associated with this identifier
    */
   Element validateElement2(Element element) {
     if (element == null) {
       return null;
     }
     ASTNode parent = this.parent;
-    if (parent is ClassDeclaration && identical((parent as ClassDeclaration).name, this)) {
+    if (parent is ClassDeclaration && identical(parent.name, this)) {
       return validateElement(parent, ClassElement, element);
-    } else if (parent is ClassTypeAlias && identical((parent as ClassTypeAlias).name, this)) {
+    } else if (parent is ClassTypeAlias && identical(parent.name, this)) {
       return validateElement(parent, ClassElement, element);
-    } else if (parent is DeclaredIdentifier && identical((parent as DeclaredIdentifier).identifier, this)) {
+    } else if (parent is DeclaredIdentifier && identical(parent.identifier, this)) {
       return validateElement(parent, LocalVariableElement, element);
-    } else if (parent is FormalParameter && identical((parent as FormalParameter).identifier, this)) {
+    } else if (parent is FormalParameter && identical(parent.identifier, this)) {
       return validateElement(parent, ParameterElement, element);
-    } else if (parent is FunctionDeclaration && identical((parent as FunctionDeclaration).name, this)) {
+    } else if (parent is FunctionDeclaration && identical(parent.name, this)) {
       return validateElement(parent, ExecutableElement, element);
-    } else if (parent is FunctionTypeAlias && identical((parent as FunctionTypeAlias).name, this)) {
+    } else if (parent is FunctionTypeAlias && identical(parent.name, this)) {
       return validateElement(parent, FunctionTypeAliasElement, element);
-    } else if (parent is MethodDeclaration && identical((parent as MethodDeclaration).name, this)) {
+    } else if (parent is MethodDeclaration && identical(parent.name, this)) {
       return validateElement(parent, ExecutableElement, element);
-    } else if (parent is TypeParameter && identical((parent as TypeParameter).name, this)) {
+    } else if (parent is TypeParameter && identical(parent.name, this)) {
       return validateElement(parent, TypeParameterElement, element);
-    } else if (parent is VariableDeclaration && identical((parent as VariableDeclaration).name, this)) {
+    } else if (parent is VariableDeclaration && identical(parent.name, this)) {
       return validateElement(parent, VariableElement, element);
     }
     return element;
   }
 }
 
 /**
  * Instances of the class `SimpleStringLiteral` represent a string literal expression that
  * does not contain any interpolations.
  *
@@ skipping 1430 matching lines @@
   /**
    * This overridden implementation of getDocumentationComment() looks in the grandparent node for
    * dartdoc comments if no documentation is specifically available on the node.
    */
   Comment get documentationComment {
     Comment comment = super.documentationComment;
     if (comment == null) {
       if (parent != null && parent.parent != null) {
         ASTNode node = parent.parent;
         if (node is AnnotatedNode) {
-          return (node as AnnotatedNode).documentationComment;
+          return node.documentationComment;
         }
       }
     }
     return comment;
   }
 
   VariableElement get element => _name != null ? (_name.staticElement as VariableElement) : null;
 
   Token get endToken {
     if (_initializer != null) {
@@ skipping 17 matching lines @@
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    *
    * @return `true` if this variable was declared with the 'const' modifier
    */
   bool get isConst {
     ASTNode parent = this.parent;
-    return parent is VariableDeclarationList && (parent as VariableDeclarationList).isConst;
+    return parent is VariableDeclarationList && parent.isConst;
   }
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
    *
    * @return `true` if this variable was declared with the 'final' modifier
    */
   bool get isFinal {
     ASTNode parent = this.parent;
-    return parent is VariableDeclarationList && (parent as VariableDeclarationList).isFinal;
+    return parent is VariableDeclarationList && parent.isFinal;
   }
 
   /**
    * Set the expression used to compute the initial value for the variable to the given expression.
    *
    * @param initializer the expression used to compute the initial value for the variable
    */
   void set initializer(Expression initializer) {
     this._initializer = becomeParentOf(initializer);
   }
@@ skipping 473 matching lines @@
     if (identical(leftOperand, NOT_A_CONSTANT)) {
       return leftOperand;
     }
     Object rightOperand = node.rightOperand.accept(this);
     if (identical(rightOperand, NOT_A_CONSTANT)) {
       return rightOperand;
     }
     while (true) {
       if (node.operator.type == TokenType.AMPERSAND) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) & (rightOperand as int);
+          return leftOperand & rightOperand;
         }
       } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
         if (leftOperand is bool && rightOperand is bool) {
-          return (leftOperand as bool) && (rightOperand as bool);
+          return leftOperand && rightOperand;
         }
       } else if (node.operator.type == TokenType.BANG_EQ) {
         if (leftOperand is bool && rightOperand is bool) {
-          return (leftOperand as bool) != (rightOperand as bool);
+          return leftOperand != rightOperand;
         } else if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) != rightOperand;
+          return leftOperand != rightOperand;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) != rightOperand;
+          return leftOperand != rightOperand;
         } else if (leftOperand is String && rightOperand is String) {
-          return (leftOperand as String) != rightOperand;
+          return leftOperand != rightOperand;
         }
       } else if (node.operator.type == TokenType.BAR) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) | (rightOperand as int);
+          return leftOperand | rightOperand;
         }
       } else if (node.operator.type == TokenType.BAR_BAR) {
         if (leftOperand is bool && rightOperand is bool) {
-          return (leftOperand as bool) || (rightOperand as bool);
+          return leftOperand || rightOperand;
         }
       } else if (node.operator.type == TokenType.CARET) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) ^ (rightOperand as int);
+          return leftOperand ^ rightOperand;
         }
       } else if (node.operator.type == TokenType.EQ_EQ) {
         if (leftOperand is bool && rightOperand is bool) {
-          return identical(leftOperand as bool, rightOperand as bool);
+          return identical(leftOperand, rightOperand);
         } else if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) == rightOperand;
+          return leftOperand == rightOperand;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) == rightOperand;
+          return leftOperand == rightOperand;
         } else if (leftOperand is String && rightOperand is String) {
-          return (leftOperand as String) == rightOperand;
+          return leftOperand == rightOperand;
         }
       } else if (node.operator.type == TokenType.GT) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int).compareTo(rightOperand as int) > 0;
+          return leftOperand.compareTo(rightOperand) > 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double).compareTo(rightOperand as double) > 0;
+          return leftOperand.compareTo(rightOperand) > 0;
         }
       } else if (node.operator.type == TokenType.GT_EQ) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int).compareTo(rightOperand as int) >= 0;
+          return leftOperand.compareTo(rightOperand) >= 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double).compareTo(rightOperand as double) >= 0;
+          return leftOperand.compareTo(rightOperand) >= 0;
         }
       } else if (node.operator.type == TokenType.GT_GT) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) >> (rightOperand as int);
+          return leftOperand >> rightOperand;
         }
       } else if (node.operator.type == TokenType.LT) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int).compareTo(rightOperand as int) < 0;
+          return leftOperand.compareTo(rightOperand) < 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double).compareTo(rightOperand as double) < 0;
+          return leftOperand.compareTo(rightOperand) < 0;
         }
       } else if (node.operator.type == TokenType.LT_EQ) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int).compareTo(rightOperand as int) <= 0;
+          return leftOperand.compareTo(rightOperand) <= 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double).compareTo(rightOperand as double) <= 0;
+          return leftOperand.compareTo(rightOperand) <= 0;
         }
       } else if (node.operator.type == TokenType.LT_LT) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) << (rightOperand as int);
+          return leftOperand << rightOperand;
         }
       } else if (node.operator.type == TokenType.MINUS) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) - (rightOperand as int);
+          return leftOperand - rightOperand;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) - (rightOperand as double);
+          return leftOperand - rightOperand;
         }
       } else if (node.operator.type == TokenType.PERCENT) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int).remainder(rightOperand as int);
+          return leftOperand.remainder(rightOperand);
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) % (rightOperand as double);
+          return leftOperand % rightOperand;
         }
       } else if (node.operator.type == TokenType.PLUS) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) + (rightOperand as int);
+          return leftOperand + rightOperand;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) + (rightOperand as double);
+          return leftOperand + rightOperand;
         }
       } else if (node.operator.type == TokenType.STAR) {
         if (leftOperand is int && rightOperand is int) {
-          return (leftOperand as int) * (rightOperand as int);
+          return leftOperand * rightOperand;
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) * (rightOperand as double);
+          return leftOperand * rightOperand;
         }
       } else if (node.operator.type == TokenType.SLASH) {
         if (leftOperand is int && rightOperand is int) {
           if (rightOperand != 0) {
-            return (leftOperand as int) ~/ (rightOperand as int);
+            return leftOperand ~/ rightOperand;
           } else {
-            return (leftOperand as int).toDouble() / (rightOperand as int).toDouble();
+            return leftOperand.toDouble() / rightOperand.toDouble();
           }
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) / (rightOperand as double);
+          return leftOperand / rightOperand;
         }
       } else if (node.operator.type == TokenType.TILDE_SLASH) {
         if (leftOperand is int && rightOperand is int) {
           if (rightOperand != 0) {
-            return (leftOperand as int) ~/ (rightOperand as int);
+            return leftOperand ~/ rightOperand;
           } else {
             return 0;
           }
         } else if (leftOperand is double && rightOperand is double) {
-          return (leftOperand as double) ~/ (rightOperand as double);
+          return leftOperand ~/ rightOperand;
         }
       }
       break;
     }
     return visitExpression(node);
   }
 
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
 
   Object visitDoubleLiteral(DoubleLiteral node) => node.value;
@@ skipping 52 matching lines @@
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
         if (identical(operand, true)) {
           return false;
         } else if (identical(operand, false)) {
           return true;
         }
       } else if (node.operator.type == TokenType.TILDE) {
         if (operand is int) {
-          return ~(operand as int);
+          return ~operand;
         }
       } else if (node.operator.type == TokenType.MINUS) {
         if (operand == null) {
           return null;
         } else if (operand is int) {
-          return -(operand as int);
+          return -operand;
         } else if (operand is double) {
-          return -(operand as double);
+          return -operand;
         }
       }
       break;
     }
     return NOT_A_CONSTANT;
   }
 
   Object visitPropertyAccess(PropertyAccess node) => getConstantValue(null);
 
   Object visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(null);
@@ skipping 24 matching lines @@
   }
 
   /**
    * Return the constant value of the static constant represented by the given element.
    *
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
-      FieldElement field = element as FieldElement;
+      FieldElement field = element;
       if (field.isStatic && field.isConst) {
       }
     }
     return NOT_A_CONSTANT;
   }
 }
 
 /**
  * Instances of the class `ElementLocator` locate the [Element]
  * associated with a given [ASTNode].
  *
  * @coverage dart.engine.ast
  */
 class ElementLocator {
   /**
    * Locate the [Element] associated with the given [ASTNode].
    *
    * @param node the node (not `null`)
    * @return the associated element, or `null` if none is found
    */
   static Element locate(ASTNode node) {
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
     return node.accept(mapper);
   }
+
+  /**
+   * Locate the [Element] associated with the given [ASTNode] and offset.
+   *
+   * @param node the node (not `null`)
+   * @param offset the offset relative to source
+   * @return the associated element, or `null` if none is found
+   */
+  static Element locate2(ASTNode node, int offset) {
+    {
+      Element nodeElement = locate(node);
+      if (nodeElement != null) {
+        return nodeElement;
+      }
+    }
+    {
+      Element element = null;
+      if (element != null) {
+        return element;
+      }
+    }
+    return null;
+  }
 }
 
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
   Element visitAssignmentExpression(AssignmentExpression node) => node.bestElement;
 
   Element visitBinaryExpression(BinaryExpression node) => node.bestElement;
 
   Element visitClassDeclaration(ClassDeclaration node) => node.element;
 
   Element visitCompilationUnit(CompilationUnit node) => node.element;
 
   Element visitConstructorDeclaration(ConstructorDeclaration node) => node.element;
 
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
 
   Element visitIdentifier(Identifier node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
-      ConstructorDeclaration decl = parent as ConstructorDeclaration;
+      ConstructorDeclaration decl = parent;
       Identifier returnType = decl.returnType;
       if (identical(returnType, node)) {
         SimpleIdentifier name = decl.name;
         if (name != null) {
           return name.bestElement;
         }
         Element element = node.bestElement;
         if (element is ClassElement) {
-          return (element as ClassElement).unnamedConstructor;
+          return element.unnamedConstructor;
         }
       }
     }
     if (parent is LibraryIdentifier) {
-      ASTNode grandParent = (parent as LibraryIdentifier).parent;
+      ASTNode grandParent = parent.parent;
       if (grandParent is PartOfDirective) {
-        Element element = (grandParent as PartOfDirective).element;
+        Element element = grandParent.element;
         if (element is LibraryElement) {
-          return (element as LibraryElement).definingCompilationUnit;
+          return element.definingCompilationUnit;
         }
       }
     }
     Element element = node.bestElement;
     if (element == null) {
       element = node.staticElement;
     }
     return element;
   }
 
@@ skipping 11 matching lines @@
 
   Element visitPostfixExpression(PostfixExpression node) => node.bestElement;
 
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.bestElement;
 
   Element visitPrefixExpression(PrefixExpression node) => node.bestElement;
 
   Element visitStringLiteral(StringLiteral node) {
     ASTNode parent = node.parent;
     if (parent is UriBasedDirective) {
-      return (parent as UriBasedDirective).uriElement;
+      return parent.uriElement;
     }
     return null;
   }
 
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 
 /**
  * Instances of the class `GeneralizingASTVisitor` implement an AST visitor that will
  * recursively visit all of the nodes in an AST structure (like instances of the class
@@ skipping 3680 matching lines @@
 
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), clone4(node.body));
 
   WithClause visitWithClause(WithClause node) => new WithClause(map(node.withKeyword), clone5(node.mixinTypes));
 
   ASTNode clone4(ASTNode node) {
     if (node == null) {
       return null;
     }
     if (identical(node, _oldNode)) {
-      return _newNode as ASTNode;
+      return _newNode;
     }
     return node.accept(this) as ASTNode;
   }
 
   List clone5(NodeList nodes) {
     List clonedNodes = new List();
     for (ASTNode node in nodes) {
       clonedNodes.add(clone4(node));
     }
     return clonedNodes;
@@ skipping 163 matching lines @@
    * Some statements define names that are visible downstream. There aren't many of these.
    *
    * @param statements the list of statements to check for name definitions
    */
   void checkStatements(List<Statement> statements) {
     for (Statement stmt in statements) {
       if (identical(stmt, _immediateChild)) {
         return;
       }
       if (stmt is VariableDeclarationStatement) {
-        addVariables((stmt as VariableDeclarationStatement).variables.variables);
+        addVariables(stmt.variables.variables);
       } else if (stmt is FunctionDeclarationStatement && !_referenceIsWithinLocalFunction) {
-        addToScope((stmt as FunctionDeclarationStatement).functionDeclaration.name);
+        addToScope(stmt.functionDeclaration.name);
       }
     }
   }
 
   bool isInRange(ASTNode node) {
     if (_position < 0) {
       return true;
     }
     return node.end < _position;
   }
@@ skipping 110 matching lines @@
   }
   void operator[]=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: ${index}, Size: ${_elements.length}");
     }
     owner.becomeParentOf(node);
     _elements[index] = node;
   }
   int get length => _elements.length;
 }