/*
 * Copyright (c) 2012, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.dart.compiler.ast;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.dart.compiler.common.SourceInfo;
import com.google.dart.compiler.parser.Token;
import com.google.dart.compiler.resolver.Element;
import com.google.dart.compiler.resolver.ElementKind;
import com.google.dart.compiler.resolver.FieldElement;
import com.google.dart.compiler.resolver.MethodElement;
import com.google.dart.compiler.resolver.VariableElement;
import com.google.dart.compiler.type.InterfaceType;
import com.google.dart.compiler.type.Type;
import com.google.dart.compiler.type.TypeKind;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Defines utility methods that operate on nodes in a Dart AST structure (instances of
 * {@link DartNode} and its subclasses).
 */
public class ASTNodes {

  /**
   * @return <code>true</code> if given {@link DartNode} is part of static method, static field or
   *         top-level function.
   */
  public static boolean isStaticContext(DartNode node) {
    while (node != null) {
      DartNode parent = node.getParent();
      if (node instanceof DartMethodDefinition) {
        DartMethodDefinition method = (DartMethodDefinition) node;
        if (method.getModifiers().isStatic()) {
          return true;
        }
        return parent instanceof DartUnit;
      }
      if (node instanceof DartField) {
        DartField field = (DartField) node;
        if (field.getModifiers().isStatic()) {
          return true;
        }
        return parent != null && parent.getParent() instanceof DartUnit;
      }
      node = parent;
    }
    return false;
  }

  /**
   * @return <code>true</code> if given {@link DartNode} is part of factory method.
   */
  public static boolean isFactoryContext(DartNode node) {
    while (node != null) {
      if (node instanceof DartMethodDefinition) {
        DartMethodDefinition method = (DartMethodDefinition) node;
        return method.getModifiers().isFactory();
      }
      node = node.getParent();
    }
    return false;
  }

  /**
   * @return <code>true</code> if given {@link DartNode} is part of static method or factory.
   */
  public static boolean isStaticOrFactoryContext(DartNode node) {
    return isFactoryContext(node) || isStaticContext(node);
  }
  
  /**
   * Returns complete field access node for given field name.
   * 
   * <pre>
   * node = 1;        => node
   * obj.node = 1;    => obj.node
   * </pre>
   * 
   * Note, that we don't check if given {@link DartNode} is actually field name.
   */
  public static DartNode getPropertyAccessNode(DartNode node) {
    DartNode parent = node.getParent();
    if (parent instanceof DartPropertyAccess && ((DartPropertyAccess) parent).getName() == node) {
      return parent;
    }
    return node;
  }

  public static List<DartNode> findDeepestCommonPath(List<DartNode> nodes) {
    List<List<DartNode>> parents = Lists.newArrayList();
    for (DartNode node : nodes) {
      parents.add(getParents(node));
    }
    return getLongestListPrefix(parents);
  }

  /**
   * @return the {@link DartNode} of given {@link Class} which is given {@link DartNode} itself, or
   *         one of its parents.
   */
  @SuppressWarnings("unchecked")
  public static <E extends DartNode> E getAncestor(DartNode node, Class<E> enclosingClass) {
    while (node != null && !enclosingClass.isInstance(node)) {
      node = node.getParent();
    };
    return (E) node;
  }

  /**
   * Get the element associated with the given AST node.
   * 
   * @param node the target node
   * @param includeDeclarations <code>true</code> if elements should be returned for declaration
   *          sites as well as for reference sites
   * @return the associated element (or <code>null</code> if none can be found)
   */
  public static Element getElement(DartNode node, boolean includeDeclarations) {
    Element targetElement = node.getElement();
    DartNode parent = node.getParent();
    // name of named parameter in invocation
    if (node instanceof DartIdentifier && node.getParent() instanceof DartNamedExpression) {
      DartNamedExpression namedExpression = (DartNamedExpression) node.getParent();
      if (namedExpression.getName() == node) {
        Object parameterId = ((DartIdentifier) node).getInvocationParameterId();
        if (parameterId instanceof VariableElement) {
          targetElement = (VariableElement) parameterId;
        }
      }
    }
    // target of "new X()" or "new X.a()" is not just a type, it is a constructor
    if (parent instanceof DartTypeNode || parent instanceof DartPropertyAccess) {
      DartNode grandparent = parent.getParent();
      if (grandparent instanceof DartNewExpression) {
        targetElement = ((DartNewExpression) grandparent).getElement();
      }
    } else if (parent instanceof DartRedirectConstructorInvocation
        || parent instanceof DartSuperConstructorInvocation) {
      targetElement = parent.getElement();
    }
    return targetElement;
  }

  /**
   * Return the class definition enclosing the given node, or <code>null</code> if the node is not a
   * child of a class definition.
   * 
   * @param node the node enclosed in the class definition to be returned
   * @return the class definition enclosing the given node
   */
  public static DartClass getEnclosingDartClass(DartNode node) {
    return getEnclosingNodeOfType(DartClass.class, node);
  }

  /**
   * Return the first node of the given class that encloses the given node, or <code>null</code> if
   * the node is not a child of a node of the given class. The node itself will <b>not</b> be
   * returned, even if it is an instance of the given class.
   * 
   * @param enclosingNodeClass the class of node to be returned
   * @param node the child of the node to be returned
   * @return the specified parent of the given node
   */
  @SuppressWarnings("unchecked")
  public static <E extends DartNode> E getEnclosingNodeOfType(Class<E> enclosingNodeClass,
      DartNode node) {
    DartNode parent = node.getParent();
    while (parent != null && !enclosingNodeClass.isInstance(parent)) {
      parent = parent.getParent();
    }
    return (E) parent;
  }

  public static int getExclusiveEnd(DartNode node) {
    SourceInfo sourceInfo = node.getSourceInfo();
    return sourceInfo.getOffset() + sourceInfo.getLength();
  }

  /**
   * @return the {@link FieldElement} with {@link ElementKind#VARIABLE} if the given
   *         {@link DartIdentifier} is the field reference, or <code>null</code> in the other case.
   */
  public static FieldElement getFieldElement(DartIdentifier node) {
    Element element = node.getElement();
    if (ElementKind.of(element) == ElementKind.FIELD) {
      return (FieldElement) element;
    }
    return null;
  }

  public static int getInclusiveEnd(DartNode node) {
    SourceInfo sourceInfo = node.getSourceInfo();
    return sourceInfo.getOffset() + sourceInfo.getLength() - 1;
  }

  /**
   * @return the {@link DartExpression} qualified if given node is name part of
   *         {@link DartPropertyAccess}. May be <code>null</code>.
   */
  public static DartNode getNodeQualifier(DartIdentifier node) {
    if (node.getParent() instanceof DartPropertyAccess) {
      DartPropertyAccess propertyAccess = (DartPropertyAccess) node.getParent();
      if (propertyAccess.getName() == node) {
        return propertyAccess.getQualifier();
      }
    }
    return null;
  }

  /**
   * @return the {@link VariableElement} if the given {@link DartIdentifier} is the parameter
   *         reference, or <code>null</code> in the other case.
   */
  public static VariableElement getParameterElement(DartIdentifier node) {
    Element element = node.getElement();
    if (ElementKind.of(element) == ElementKind.PARAMETER) {
      return (VariableElement) element;
    }
    return null;
  }

  /**
   * @return the index of given {@link VariableElement} in parameters, or <code>-1</code> if not
   *         parameter.
   */
  public static int getParameterIndex(VariableElement variableElement) {
    Element enclosingElement = variableElement.getEnclosingElement();
    if (enclosingElement instanceof MethodElement) {
      MethodElement methodElement = (MethodElement) enclosingElement;
      return methodElement.getParameters().indexOf(variableElement);
    }
    return -1;
  }

  /**
   * Returns the closest ancestor of <code>node</code> that is an instance of
   * <code>parentClass</code>, or <code>null</code> if none.
   * <p>
   * <b>Warning:</b> This method does not stop at any boundaries like parentheses, statements, body
   * declarations, etc. The resulting node may be in a totally different scope than the given node.
   * Consider using one of the {@link ASTResolving}<code>.find(..)</code> methods instead.
   * </p>
   * 
   * @param node the node
   * @param parentClass the class of the sought ancestor node
   * @return the closest ancestor of <code>node</code> that is an instance of
   *         <code>parentClass</code>, or <code>null</code> if none
   */
  @SuppressWarnings("unchecked")
  public static <E extends DartNode> E getParent(DartNode node, Class<E> parentClass) {
    do {
      node = node.getParent();
    } while (node != null && !parentClass.isInstance(node));
    return (E) node;
  }

//  private static class ChildrenCollector extends ASTVisitor<Void> {
//    public List<DartNode> result;
//
//    @Override
//    public Void visitNode(DartNode node) {
//      // first visitNode: on the node's parent: do nothing, return true
//      if (result == null) {
//        result = Lists.newArrayList();
//        return super.visitNode(node);
//      } else {
//        result.add(node);
//      }
//    }
//  }
//
//  public static final int NODE_ONLY = 0;
//  public static final int INCLUDE_FIRST_PARENT = 1;
//
//  public static final int INCLUDE_ALL_PARENTS = 2;
//  public static final int WARNING = 1 << 0;
//  public static final int ERROR = 1 << 1;
//
//  public static final int PROBLEMS = WARNING | ERROR;
//  private static final Message[] EMPTY_MESSAGES = new Message[0];
//
//  private static final IProblem[] EMPTY_PROBLEMS = new IProblem[0];
//
//  private static final int CLEAR_VISIBILITY =
//      ~(Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE);
//
//  public static String asFormattedString(DartNode node,
//      int indent,
//      String lineDelim,
//      Map<String, String> options) {
//    String unformatted = asString(node);
//    TextEdit edit = CodeFormatterUtil.format2(node, unformatted, indent, lineDelim, options);
//    if (edit != null) {
//      Document document = new Document(unformatted);
//      try {
//        edit.apply(document, TextEdit.NONE);
//      } catch (BadLocationException e) {
//        JavaPlugin.log(e);
//      }
//      return document.get();
//    }
//    return unformatted; // unknown node
//  }
//
//  public static String asString(DartNode node) {
//    ASTFlattener flattener = new ASTFlattener();
//    node.accept(flattener);
//    return flattener.getResult();
//  }
//
//  public static int changeVisibility(int modifiers, int visibility) {
//    return modifiers & CLEAR_VISIBILITY | visibility;
//  }
//
//  public static InfixExpression.Operator convertToInfixOperator(Assignment.Operator operator) {
//    if (operator.equals(Assignment.Operator.PLUS_ASSIGN)) {
//      return InfixExpression.Operator.PLUS;
//    }
//
//    if (operator.equals(Assignment.Operator.MINUS_ASSIGN)) {
//      return InfixExpression.Operator.MINUS;
//    }
//
//    if (operator.equals(Assignment.Operator.TIMES_ASSIGN)) {
//      return InfixExpression.Operator.TIMES;
//    }
//
//    if (operator.equals(Assignment.Operator.DIVIDE_ASSIGN)) {
//      return InfixExpression.Operator.DIVIDE;
//    }
//
//    if (operator.equals(Assignment.Operator.BIT_AND_ASSIGN)) {
//      return InfixExpression.Operator.AND;
//    }
//
//    if (operator.equals(Assignment.Operator.BIT_OR_ASSIGN)) {
//      return InfixExpression.Operator.OR;
//    }
//
//    if (operator.equals(Assignment.Operator.BIT_XOR_ASSIGN)) {
//      return InfixExpression.Operator.XOR;
//    }
//
//    if (operator.equals(Assignment.Operator.REMAINDER_ASSIGN)) {
//      return InfixExpression.Operator.REMAINDER;
//    }
//
//    if (operator.equals(Assignment.Operator.LEFT_SHIFT_ASSIGN)) {
//      return InfixExpression.Operator.LEFT_SHIFT;
//    }
//
//    if (operator.equals(Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN)) {
//      return InfixExpression.Operator.RIGHT_SHIFT_SIGNED;
//    }
//
//    if (operator.equals(Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN)) {
//      return InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED;
//    }
//
//    Assert.isTrue(false, "Cannot convert assignment operator"); //$NON-NLS-1$
//    return null;
//  }
//
//  public static DartNode findDeclaration(IBinding binding, DartNode root) {
//    root = root.getRoot();
//    if (root instanceof CompilationUnit) {
//      return ((CompilationUnit) root).findDeclaringNode(binding);
//    }
//    return null;
//  }
//
//  public static Modifier findModifierNode(int flag, List<IExtendedModifier> modifiers) {
//    for (int i = 0; i < modifiers.size(); i++) {
//      Object curr = modifiers.get(i);
//      if (curr instanceof Modifier && ((Modifier) curr).getKeyword().toFlagValue() == flag) {
//        return (Modifier) curr;
//      }
//    }
//    return null;
//  }
//
//  public static DartNode findParent(DartNode node, StructuralPropertyDescriptor[][] pathes) {
//    for (int p = 0; p < pathes.length; p++) {
//      StructuralPropertyDescriptor[] path = pathes[p];
//      DartNode current = node;
//      int d = path.length - 1;
//      for (; d >= 0 && current != null; d--) {
//        StructuralPropertyDescriptor descriptor = path[d];
//        if (!descriptor.equals(current.getLocationInParent())) {
//          break;
//        }
//        current = current.getParent();
//      }
//      if (d < 0) {
//        return current;
//      }
//    }
//    return null;
//  }
//
//  public static VariableDeclaration findVariableDeclaration(IVariableBinding binding, DartNode root) {
//    if (binding.isField()) {
//      return null;
//    }
//    DartNode result = findDeclaration(binding, root);
//    if (result instanceof VariableDeclaration) {
//      return (VariableDeclaration) result;
//    }
//
//    return null;
//  }
//
//  public static List<BodyDeclaration> getBodyDeclarations(DartNode node) {
//    if (node instanceof AbstractTypeDeclaration) {
//      return ((AbstractTypeDeclaration) node).bodyDeclarations();
//    } else if (node instanceof AnonymousClassDeclaration) {
//      return ((AnonymousClassDeclaration) node).bodyDeclarations();
//    }
//    // should not happen.
//    Assert.isTrue(false);
//    return null;
//  }
//
//  /**
//   * Returns the structural property descriptor for the "bodyDeclarations" property of this node
//   * (element type: {@link BodyDeclaration}).
//   * 
//   * @param node the node, either an {@link AbstractTypeDeclaration} or an
//   *          {@link AnonymousClassDeclaration}
//   * @return the property descriptor
//   */
//  public static ChildListPropertyDescriptor getBodyDeclarationsProperty(DartNode node) {
//    if (node instanceof AbstractTypeDeclaration) {
//      return ((AbstractTypeDeclaration) node).getBodyDeclarationsProperty();
//    } else if (node instanceof AnonymousClassDeclaration) {
//      return AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY;
//    }
//    // should not happen.
//    Assert.isTrue(false);
//    return null;
//  }
//
//  /**
//   * Returns a list of the direct children of a node. The siblings are ordered by start offset.
//   * 
//   * @param node the node to get the children for
//   * @return the children
//   */
//  public static List<DartNode> getChildren(DartNode node) {
//    ChildrenCollector visitor = new ChildrenCollector();
//    node.accept(visitor);
//    return visitor.result;
//  }
//
//  /**
//   * Returns the list that contains the given DartNode. If the node isn't part of any list,
//   * <code>null</code> is returned.
//   * 
//   * @param node the node in question
//   * @return the list that contains the node or <code>null</code>
//   */
//  public static List<? extends DartNode> getContainingList(DartNode node) {
//    StructuralPropertyDescriptor locationInParent = node.getLocationInParent();
//    if (locationInParent != null && locationInParent.isChildListProperty()) {
//      return (List<? extends DartNode>) node.getParent().getStructuralProperty(locationInParent);
//    }
//    return null;
//  }
//
//  public static int getDimensions(VariableDeclaration declaration) {
//    int dim = declaration.getExtraDimensions();
//    Type type = getType(declaration);
//    if (type instanceof ArrayType) {
//      dim += ((ArrayType) type).getDimensions();
//    }
//    return dim;
//  }
//
//  /**
//   * Returns the element type. This is a convenience method that returns its argument if it is a
//   * simple type and the element type if the parameter is an array type.
//   * 
//   * @param type The type to get the element type from.
//   * @return The element type of the type or the type itself.
//   */
//  public static Type getElementType(Type type) {
//    if (!type.isArrayType()) {
//      return type;
//    }
//    return ((ArrayType) type).getElementType();
//  }
//
//  public static ITypeBinding getEnclosingType(DartNode node) {
//    while (node != null) {
//      if (node instanceof AbstractTypeDeclaration) {
//        return ((AbstractTypeDeclaration) node).resolveBinding();
//      } else if (node instanceof AnonymousClassDeclaration) {
//        return ((AnonymousClassDeclaration) node).resolveBinding();
//      }
//      node = node.getParent();
//    }
//    return null;
//  }
//
//  public static int getExclusiveEnd(DartNode node) {
//    return node.getStartPosition() + node.getLength();
//  }
//
//  /**
//   * Returns the type to which an inlined variable initializer should be cast, or <code>null</code>
//   * if no cast is necessary.
//   * 
//   * @param initializer the initializer expression of the variable to inline
//   * @param reference the reference to the variable (which is to be inlined)
//   * @return a type binding to which the initializer should be cast, or <code>null</code> iff no
//   *         cast is necessary
//   */
//  public static ITypeBinding getExplicitCast(Expression initializer, Expression reference) {
//    ITypeBinding initializerType = initializer.resolveTypeBinding();
//    ITypeBinding referenceType = reference.resolveTypeBinding();
//    if (initializerType == null || referenceType == null) {
//      return null;
//    }
//
//    if (initializerType.isPrimitive()
//        && referenceType.isPrimitive()
//        && !referenceType.isEqualTo(initializerType)) {
//      return referenceType;
//
//    } else if (initializerType.isPrimitive() && !referenceType.isPrimitive()) { // initializer is autoboxed
//      ITypeBinding unboxedReferenceType =
//          Bindings.getUnboxedTypeBinding(referenceType, reference.getAST());
//      if (!unboxedReferenceType.isEqualTo(initializerType)) {
//        return unboxedReferenceType;
//      } else if (needsExplicitBoxing(reference)) {
//        return referenceType;
//      }
//
//    } else if (!initializerType.isPrimitive() && referenceType.isPrimitive()) { // initializer is autounboxed
//      ITypeBinding unboxedInitializerType =
//          Bindings.getUnboxedTypeBinding(initializerType, reference.getAST());
//      if (!unboxedInitializerType.isEqualTo(referenceType)) {
//        return referenceType;
//      }
//
//    } else if (initializerType.isRawType() && referenceType.isParameterizedType()) {
//      return referenceType; // don't lose the unchecked conversion
//
//    } else if (!TypeRules.canAssign(initializerType, referenceType)) {
//      if (!Bindings.containsTypeVariables(referenceType)) {
//        return referenceType;
//      }
//    }
//
//    return null;
//  }
//
//  public static IVariableBinding getFieldBinding(Name node) {
//    IVariableBinding result = getVariableBinding(node);
//    if (result == null || !result.isField()) {
//      return null;
//    }
//
//    return result;
//  }
//
//  public static int getInclusiveEnd(DartNode node) {
//    return node.getStartPosition() + node.getLength() - 1;
//  }
//
//  /**
//   * Computes the insertion index to be used to add the given member to the the list
//   * <code>container</code>.
//   * 
//   * @param member the member to add
//   * @param container a list containing objects of type <code>BodyDeclaration</code>
//   * @return the insertion index to be used
//   */
//  public static int getInsertionIndex(BodyDeclaration member,
//      List<? extends BodyDeclaration> container) {
//    int containerSize = container.size();
//
//    MembersOrderPreferenceCache orderStore =
//        JavaPlugin.getDefault().getMemberOrderPreferenceCache();
//
//    int orderIndex = getOrderPreference(member, orderStore);
//
//    int insertPos = containerSize;
//    int insertPosOrderIndex = -1;
//
//    for (int i = containerSize - 1; i >= 0; i--) {
//      int currOrderIndex = getOrderPreference(container.get(i), orderStore);
//      if (orderIndex == currOrderIndex) {
//        if (insertPosOrderIndex != orderIndex) { // no perfect match yet
//          insertPos = i + 1; // after a same kind
//          insertPosOrderIndex = orderIndex; // perfect match
//        }
//      } else if (insertPosOrderIndex != orderIndex) { // not yet a perfect match
//        if (currOrderIndex < orderIndex) { // we are bigger
//          if (insertPosOrderIndex == -1) {
//            insertPos = i + 1; // after
//            insertPosOrderIndex = currOrderIndex;
//          }
//        } else {
//          insertPos = i; // before
//          insertPosOrderIndex = currOrderIndex;
//        }
//      }
//    }
//    return insertPos;
//  }
//
//  public static SimpleName getLeftMostSimpleName(Name name) {
//    if (name instanceof SimpleName) {
//      return (SimpleName) name;
//    } else {
//      final SimpleName[] result = new SimpleName[1];
//      ASTVisitor visitor = new ASTVisitor() {
//        @Override
//        public boolean visit(QualifiedName qualifiedName) {
//          Name left = qualifiedName.getQualifier();
//          if (left instanceof SimpleName) {
//            result[0] = (SimpleName) left;
//          } else {
//            left.accept(this);
//          }
//          return false;
//        }
//      };
//      name.accept(visitor);
//      return result[0];
//    }
//  }
//
//  public static SimpleType getLeftMostSimpleType(QualifiedType type) {
//    final SimpleType[] result = new SimpleType[1];
//    ASTVisitor visitor = new ASTVisitor() {
//      @Override
//      public boolean visit(QualifiedType qualifiedType) {
//        Type left = qualifiedType.getQualifier();
//        if (left instanceof SimpleType) {
//          result[0] = (SimpleType) left;
//        } else {
//          left.accept(this);
//        }
//        return false;
//      }
//    };
//    type.accept(visitor);
//    return result[0];
//  }
//
//  public static IVariableBinding getLocalVariableBinding(Name node) {
//    IVariableBinding result = getVariableBinding(node);
//    if (result == null || result.isField()) {
//      return null;
//    }
//
//    return result;
//  }
//
//  public static Message[] getMessages(DartNode node, int flags) {
//    DartNode root = node.getRoot();
//    if (!(root instanceof CompilationUnit)) {
//      return EMPTY_MESSAGES;
//    }
//    Message[] messages = ((CompilationUnit) root).getMessages();
//    if (root == node) {
//      return messages;
//    }
//    final int iterations = computeIterations(flags);
//    List<Message> result = new ArrayList<Message>(5);
//    for (int i = 0; i < messages.length; i++) {
//      Message message = messages[i];
//      DartNode temp = node;
//      int count = iterations;
//      do {
//        int nodeOffset = temp.getStartPosition();
//        int messageOffset = message.getStartPosition();
//        if (nodeOffset <= messageOffset && messageOffset < nodeOffset + temp.getLength()) {
//          result.add(message);
//          count = 0;
//        } else {
//          count--;
//        }
//      } while ((temp = temp.getParent()) != null && count > 0);
//    }
//    return result.toArray(new Message[result.size()]);
//  }
//
//  public static IMethodBinding getMethodBinding(Name node) {
//    IBinding binding = node.resolveBinding();
//    if (binding instanceof IMethodBinding) {
//      return (IMethodBinding) binding;
//    }
//    return null;
//  }
//
//  public static List<IExtendedModifier> getModifiers(VariableDeclaration declaration) {
//    Assert.isNotNull(declaration);
//    if (declaration instanceof SingleVariableDeclaration) {
//      return ((SingleVariableDeclaration) declaration).modifiers();
//    } else if (declaration instanceof VariableDeclarationFragment) {
//      DartNode parent = declaration.getParent();
//      if (parent instanceof VariableDeclarationExpression) {
//        return ((VariableDeclarationExpression) parent).modifiers();
//      } else if (parent instanceof VariableDeclarationStatement) {
//        return ((VariableDeclarationStatement) parent).modifiers();
//      }
//    }
//    return new ArrayList<IExtendedModifier>(0);
//  }
//
//  /**
//   * Returns the source of the given node from the location where it was parsed.
//   * 
//   * @param node the node to get the source from
//   * @param extendedRange if set, the extended ranges of the nodes should ne used
//   * @param removeIndent if set, the indentation is removed.
//   * @return return the source for the given node or null if accessing the source failed.
//   */
//  public static String getNodeSource(DartNode node, boolean extendedRange, boolean removeIndent) {
//    DartNode root = node.getRoot();
//    if (root instanceof CompilationUnit) {
//      CompilationUnit astRoot = (CompilationUnit) root;
//      ITypeRoot typeRoot = astRoot.getTypeRoot();
//      try {
//        if (typeRoot != null && typeRoot.getBuffer() != null) {
//          IBuffer buffer = typeRoot.getBuffer();
//          int offset =
//              extendedRange ? astRoot.getExtendedStartPosition(node) : node.getStartPosition();
//          int length = extendedRange ? astRoot.getExtendedLength(node) : node.getLength();
//          String str = buffer.getText(offset, length);
//          if (removeIndent) {
//            IJavaProject project = typeRoot.getJavaProject();
//            int indent = StubUtility.getIndentUsed(buffer, node.getStartPosition(), project);
//            str =
//                Strings.changeIndent(
//                    str,
//                    indent,
//                    project,
//                    new String(),
//                    typeRoot.findRecommendedLineSeparator());
//          }
//          return str;
//        }
//      } catch (JavaModelException e) {
//        // ignore
//      }
//    }
//    return null;
//  }
//
//  public static DartNode getNormalizedNode(DartNode node) {
//    DartNode current = node;
//    // normalize name
//    if (QualifiedName.NAME_PROPERTY.equals(current.getLocationInParent())) {
//      current = current.getParent();
//    }
//    // normalize type
//    if (QualifiedType.NAME_PROPERTY.equals(current.getLocationInParent())
//        || SimpleType.NAME_PROPERTY.equals(current.getLocationInParent())) {
//      current = current.getParent();
//    }
//    // normalize parameterized types
//    if (ParameterizedType.TYPE_PROPERTY.equals(current.getLocationInParent())) {
//      current = current.getParent();
//    }
//    return current;
//  }

  /**
   * @return parent {@link DartNode}s from {@link DartUnit} (at index "0") to the given one.
   */
  public static List<DartNode> getParents(DartNode node) {
    List<DartNode> parents = Lists.newArrayList();
    DartNode current = node;
    do {
      parents.add(current.getParent());
      current = current.getParent();
    } while (current.getParent() != null);
    Collections.reverse(parents);
    return parents;
  }

  /**
   * @return given {@link DartStatement} if not {@link DartBlock}, first child {@link DartStatement}
   *         if {@link DartBlock}, or <code>null</code> if more than one child.
   */
  public static DartStatement getSingleStatement(DartStatement statement) {
    if (statement instanceof DartBlock) {
      List<DartStatement> blockStatements = ((DartBlock) statement).getStatements();
      if (blockStatements.size() != 1) {
        return null;
      }
      return blockStatements.get(0);
    }
    return statement;
  }

  /**
   * @return given {@link DartStatement} if not {@link DartBlock}, all children
   *         {@link DartStatement}s if {@link DartBlock}.
   */
  public static List<DartStatement> getStatements(DartStatement statement) {
    if (statement instanceof DartBlock) {
      return ((DartBlock) statement).getStatements();
    }
    return ImmutableList.of(statement);
  }

  /**
   * @return the {@link DartThisExpression} if given node is name of {@link DartPropertyAccess} with
   *         {@link DartThisExpression} qualifier. May be <code>null</code>.
   */
  public static DartThisExpression getThisQualifier(DartIdentifier node) {
    if (node.getParent() instanceof DartPropertyAccess) {
      DartPropertyAccess propertyAccess = (DartPropertyAccess) node.getParent();
      if (propertyAccess.getName() == node
          && propertyAccess.getQualifier() instanceof DartThisExpression) {
        return (DartThisExpression) propertyAccess.getQualifier();
      }
    }
    return null;
  }

  /**
   * Return the type associated with the given type node, or <code>null</code> if the type could not
   * be determined.
   * 
   * @param typeNode the type node whose type is to be returned
   * @return the type associated with the given type node
   */
  public static Type getType(DartTypeNode typeNode) {
    Type type = typeNode.getType();
    if (type == null) {
      DartNode parent = typeNode.getParent();
      if (parent instanceof DartTypeNode) {
        Type parentType = getType((DartTypeNode) parent);
        if (parentType != null && parentType.getKind() == TypeKind.INTERFACE) {
          int index = ((DartTypeNode) parent).getTypeArguments().indexOf(typeNode);
          return ((InterfaceType) parentType).getArguments().get(index);
        }
      }
    }
    return type;
  }

  /**
   * @return the {@link VariableElement} with {@link ElementKind#VARIABLE} if the given
   *         {@link DartIdentifier} is the local variable reference, or <code>null</code> in the
   *         other case.
   */
  public static VariableElement getVariableElement(DartIdentifier node) {
    Element element = node.getElement();
    if (ElementKind.of(element) == ElementKind.VARIABLE) {
      return (VariableElement) element;
    }
    return null;
  }

  /**
   * @return the {@link VariableElement} with {@link ElementKind#VARIABLE} or
   *         {@link ElementKind#PARAMETER} if the given {@link DartIdentifier} is the reference to
   *         local variable or parameter, or <code>null</code> in the other case.
   */
  public static VariableElement getVariableOrParameterElement(DartIdentifier node) {
    Element element = node.getElement();
    if (element instanceof VariableElement) {
      return (VariableElement) element;
    }
    return null;
  }

  /**
   * Return <code>true</code> if the given method is a constructor.
   * 
   * @param method the method being tested
   * @return <code>true</code> if the given method is a constructor
   */
  public static boolean isConstructor(DartMethodDefinition method) {
    MethodElement methodElement = method.getElement();
    if (methodElement != null) {
      return methodElement.isConstructor();
    }
    return isConstructor(((DartClass) method.getParent()).getClassName(), method);
  }

  /**
   * Return <code>true</code> if the given method is a constructor.
   * 
   * @param className the name of the type containing the method definition
   * @param method the method being tested
   * @return <code>true</code> if the given method is a constructor
   */
  public static boolean isConstructor(String className, DartMethodDefinition method) {
    if (method.getModifiers().isFactory()) {
      return true;
    }
    DartExpression name = method.getName();
    if (name instanceof DartIdentifier) {
      return ((DartIdentifier) name).getName().equals(className);
    } else if (name instanceof DartPropertyAccess) {
      DartPropertyAccess property = (DartPropertyAccess) name;
      DartNode qualifier = property.getQualifier();
      if (qualifier instanceof DartIdentifier) {
        return ((DartIdentifier) qualifier).getName().equals(className);
      }
    }
    return false;
  }

  /**
   * @return <code>true</code> if given {@link DartNode} is the name of some {@link DartDeclaration}
   *         .
   */
  public static boolean isNameOfDeclaration(DartNode node) {
    return node.getParent() instanceof DartDeclaration<?>
        && ((DartDeclaration<?>) node.getParent()).getName() == node;
  }

  /**
   * @return <code>true</code> if given {@link List}s are equals at given position.
   */
  private static <T> boolean allListsEqual(List<List<T>> lists, int position) {
    T element = lists.get(0).get(position);
    for (List<T> list : lists) {
      if (list.get(position) != element) {
        return false;
      }
    }
    return true;
  }

  private static <T> List<T> getLongestListPrefix(List<List<T>> lists) {
    if (lists.isEmpty()) {
      return ImmutableList.of();
    }
    // prepare minimal length of all arrays
    int minLength = lists.get(0).size();
    for (List<T> list : lists) {
      minLength = Math.min(minLength, list.size());
    }
    // find length of the common prefix
    int length = -1;
    for (int i = 0; i < minLength; i++) {
      if (!allListsEqual(lists, i)) {
        break;
      }
      length++;
    }
    // done
    return lists.get(0).subList(0, length + 1);
  }

//  /**
//   * Returns the closest ancestor of <code>node</code> whose type is <code>nodeType</code>, or
//   * <code>null</code> if none.
//   * <p>
//   * <b>Warning:</b> This method does not stop at any boundaries like parentheses, statements, body
//   * declarations, etc. The resulting node may be in a totally different scope than the given node.
//   * Consider using one of the {@link ASTResolving}<code>.find(..)</code> methods instead.
//   * </p>
//   * 
//   * @param node the node
//   * @param nodeType the node type constant from {@link DartNode}
//   * @return the closest ancestor of <code>node</code> whose type is <code>nodeType</code>, or
//   *         <code>null</code> if none
//   */
//  public static DartNode getParent(DartNode node, int nodeType) {
//    do {
//      node = node.getParent();
//    } while (node != null && node.getNodeType() != nodeType);
//    return node;
//  }
//
//  public static IProblem[] getProblems(DartNode node, int scope, int severity) {
//    DartNode root = node.getRoot();
//    if (!(root instanceof CompilationUnit)) {
//      return EMPTY_PROBLEMS;
//    }
//    IProblem[] problems = ((CompilationUnit) root).getProblems();
//    if (root == node) {
//      return problems;
//    }
//    final int iterations = computeIterations(scope);
//    List<IProblem> result = new ArrayList<IProblem>(5);
//    for (int i = 0; i < problems.length; i++) {
//      IProblem problem = problems[i];
//      boolean consider = false;
//      if ((severity & PROBLEMS) == PROBLEMS) {
//        consider = true;
//      } else if ((severity & WARNING) != 0) {
//        consider = problem.isWarning();
//      } else if ((severity & ERROR) != 0) {
//        consider = problem.isError();
//      }
//      if (consider) {
//        DartNode temp = node;
//        int count = iterations;
//        do {
//          int nodeOffset = temp.getStartPosition();
//          int problemOffset = problem.getSourceStart();
//          if (nodeOffset <= problemOffset && problemOffset < nodeOffset + temp.getLength()) {
//            result.add(problem);
//            count = 0;
//          } else {
//            count--;
//          }
//        } while ((temp = temp.getParent()) != null && count > 0);
//      }
//    }
//    return result.toArray(new IProblem[result.size()]);
//  }
//
//  public static String getQualifier(Name name) {
//    if (name.isQualifiedName()) {
//      return ((QualifiedName) name).getQualifier().getFullyQualifiedName();
//    }
//    return ""; //$NON-NLS-1$
//  }
//
//  /**
//   * Returns the receiver's type binding of the given method invocation.
//   * 
//   * @param invocation method invocation to resolve type of
//   * @return the type binding of the receiver
//   */
//  public static ITypeBinding getReceiverTypeBinding(MethodInvocation invocation) {
//    ITypeBinding result = null;
//    Expression exp = invocation.getExpression();
//    if (exp != null) {
//      return exp.resolveTypeBinding();
//    } else {
//      AbstractTypeDeclaration type =
//          (AbstractTypeDeclaration) getParent(invocation, AbstractTypeDeclaration.class);
//      if (type != null) {
//        return type.resolveBinding();
//      }
//    }
//    return result;
//  }
//
//  public static String getSimpleNameIdentifier(Name name) {
//    if (name.isQualifiedName()) {
//      return ((QualifiedName) name).getName().getIdentifier();
//    } else {
//      return ((SimpleName) name).getIdentifier();
//    }
//  }
//
//  public static Name getTopMostName(Name name) {
//    Name result = name;
//    while (result.getParent() instanceof Name) {
//      result = (Name) result.getParent();
//    }
//    return result;
//  }
//
//  public static Type getTopMostType(Type type) {
//    Type result = type;
//    while (result.getParent() instanceof Type) {
//      result = (Type) result.getParent();
//    }
//    return result;
//  }
//
//  /**
//   * Returns the type node for the given declaration.
//   * 
//   * @param declaration the declaration
//   * @return the type node
//   */
//  public static Type getType(VariableDeclaration declaration) {
//    if (declaration instanceof SingleVariableDeclaration) {
//      return ((SingleVariableDeclaration) declaration).getType();
//    } else if (declaration instanceof VariableDeclarationFragment) {
//      DartNode parent = ((VariableDeclarationFragment) declaration).getParent();
//      if (parent instanceof VariableDeclarationExpression) {
//        return ((VariableDeclarationExpression) parent).getType();
//      } else if (parent instanceof VariableDeclarationStatement) {
//        return ((VariableDeclarationStatement) parent).getType();
//      } else if (parent instanceof FieldDeclaration) {
//        return ((FieldDeclaration) parent).getType();
//      }
//    }
//    Assert.isTrue(false, "Unknown VariableDeclaration"); //$NON-NLS-1$
//    return null;
//  }
//
//  public static ITypeBinding getTypeBinding(CompilationUnit root, IType type)
//      throws JavaModelException {
//    if (type.isAnonymous()) {
//      final IJavaElement parent = type.getParent();
//      if (parent instanceof IField && Flags.isEnum(((IMember) parent).getFlags())) {
//        final EnumConstantDeclaration constant =
//            (EnumConstantDeclaration) NodeFinder.perform(
//                root,
//                ((ISourceReference) parent).getSourceRange());
//        if (constant != null) {
//          final AnonymousClassDeclaration declaration = constant.getAnonymousClassDeclaration();
//          if (declaration != null) {
//            return declaration.resolveBinding();
//          }
//        }
//      } else {
//        final ClassInstanceCreation creation =
//            (ClassInstanceCreation) getParent(
//                NodeFinder.perform(root, type.getNameRange()),
//                ClassInstanceCreation.class);
//        if (creation != null) {
//          return creation.resolveTypeBinding();
//        }
//      }
//    } else {
//      final AbstractTypeDeclaration declaration =
//          (AbstractTypeDeclaration) getParent(
//              NodeFinder.perform(root, type.getNameRange()),
//              AbstractTypeDeclaration.class);
//      if (declaration != null) {
//        return declaration.resolveBinding();
//      }
//    }
//    return null;
//  }
//
//  public static ITypeBinding getTypeBinding(Name node) {
//    IBinding binding = node.resolveBinding();
//    if (binding instanceof ITypeBinding) {
//      return (ITypeBinding) binding;
//    }
//    return null;
//  }
//
//  public static String getTypeName(Type type) {
//    final StringBuffer buffer = new StringBuffer();
//    ASTVisitor visitor = new ASTVisitor() {
//      @Override
//      public void endVisit(ArrayType node) {
//        buffer.append("[]"); //$NON-NLS-1$
//      }
//
//      @Override
//      public boolean visit(PrimitiveType node) {
//        buffer.append(node.getPrimitiveTypeCode().toString());
//        return false;
//      }
//
//      @Override
//      public boolean visit(QualifiedName node) {
//        buffer.append(node.getName().getIdentifier());
//        return false;
//      }
//
//      @Override
//      public boolean visit(SimpleName node) {
//        buffer.append(node.getIdentifier());
//        return false;
//      }
//    };
//    type.accept(visitor);
//    return buffer.toString();
//  }
//
//  public static IVariableBinding getVariableBinding(Name node) {
//    IBinding binding = node.resolveBinding();
//    if (binding instanceof IVariableBinding) {
//      return (IVariableBinding) binding;
//    }
//    return null;
//  }
//
//  /**
//   * Returns true if a node at a given location is a body of a control statement. Such body nodes
//   * are interesting as when replacing them, it has to be evaluates if a Block is needed instead.
//   * E.g. <code> if (x) do(); -> if (x) { do1(); do2() } </code>
//   * 
//   * @param locationInParent Location of the body node
//   * @return Returns true if the location is a body node location of a control statement.
//   */
//  public static boolean isControlStatementBody(StructuralPropertyDescriptor locationInParent) {
//    return locationInParent == IfStatement.THEN_STATEMENT_PROPERTY
//        || locationInParent == IfStatement.ELSE_STATEMENT_PROPERTY
//        || locationInParent == ForStatement.BODY_PROPERTY
//        || locationInParent == EnhancedForStatement.BODY_PROPERTY
//        || locationInParent == WhileStatement.BODY_PROPERTY
//        || locationInParent == DoStatement.BODY_PROPERTY;
//  }
//
//  public static boolean isDeclaration(Name name) {
//    if (name.isQualifiedName()) {
//      return ((QualifiedName) name).getName().isDeclaration();
//    } else {
//      return ((SimpleName) name).isDeclaration();
//    }
//  }
//
//  /**
//   * Returns true if this is an existing node, i.e. it was created as part of a parsing process of a
//   * source code file. Returns false if this is a newly created node which has not yet been given a
//   * source position.
//   * 
//   * @param node the node to be tested.
//   * @return true if this is an existing node, false if not.
//   */
//  public static boolean isExistingNode(DartNode node) {
//    return node.getStartPosition() != -1;
//  }
//
//  public static boolean isLabel(SimpleName name) {
//    int parentType = name.getParent().getNodeType();
//    return parentType == DartNode.LABELED_STATEMENT
//        || parentType == DartNode.BREAK_STATEMENT
//        || parentType != DartNode.CONTINUE_STATEMENT;
//  }
//
//  public static boolean isLiteral(Expression expression) {
//    int type = expression.getNodeType();
//    return type == DartNode.BOOLEAN_LITERAL
//        || type == DartNode.CHARACTER_LITERAL
//        || type == DartNode.NULL_LITERAL
//        || type == DartNode.NUMBER_LITERAL
//        || type == DartNode.STRING_LITERAL
//        || type == DartNode.TYPE_LITERAL;
//  }
//
//  /**
//   * Returns <code>true</code> iff <code>parent</code> is a true ancestor of <code>node</code> (i.e.
//   * returns <code>false</code> if <code>parent == node</code>).
//   * 
//   * @param node node to test
//   * @param parent assumed parent
//   * @return <code>true</code> iff <code>parent</code> is a true ancestor of <code>node</code>
//   */
//  public static boolean isParent(DartNode node, DartNode parent) {
//    Assert.isNotNull(parent);
//    do {
//      node = node.getParent();
//      if (node == parent) {
//        return true;
//      }
//    } while (node != null);
//    return false;
//  }
//
//  public static boolean isSingleDeclaration(VariableDeclaration declaration) {
//    Assert.isNotNull(declaration);
//    if (declaration instanceof SingleVariableDeclaration) {
//      return true;
//    } else if (declaration instanceof VariableDeclarationFragment) {
//      DartNode parent = declaration.getParent();
//      if (parent instanceof VariableDeclarationExpression) {
//        return ((VariableDeclarationExpression) parent).fragments().size() == 1;
//      } else if (parent instanceof VariableDeclarationStatement) {
//        return ((VariableDeclarationStatement) parent).fragments().size() == 1;
//      }
//    }
//    return false;
//  }
//
//  public static boolean isStatic(BodyDeclaration declaration) {
//    return Modifier.isStatic(declaration.getModifiers());
//  }
//
//  /**
//   * Adds flags to the given node and all its descendants.
//   * 
//   * @param root The root node
//   * @param flags The flags to set
//   */
//  public static void setFlagsToAST(DartNode root, final int flags) {
//    root.accept(new GenericVisitor(true) {
//      @Override
//      protected boolean visitNode(DartNode node) {
//        node.setFlags(node.getFlags() | flags);
//        return true;
//      }
//    });
//  }
//
//  private static int computeIterations(int flags) {
//    switch (flags) {
//      case NODE_ONLY:
//        return 1;
//      case INCLUDE_ALL_PARENTS:
//        return Integer.MAX_VALUE;
//      case INCLUDE_FIRST_PARENT:
//        return 2;
//      default:
//        return 1;
//    }
//  }
//
//  private static int getOrderPreference(BodyDeclaration member, MembersOrderPreferenceCache store) {
//    int memberType = member.getNodeType();
//    int modifiers = member.getModifiers();
//
//    switch (memberType) {
//      case DartNode.TYPE_DECLARATION:
//      case DartNode.ENUM_DECLARATION:
//      case DartNode.ANNOTATION_TYPE_DECLARATION:
//        return store.getCategoryIndex(MembersOrderPreferenceCache.TYPE_INDEX) * 2;
//      case DartNode.FIELD_DECLARATION:
//        if (Modifier.isStatic(modifiers)) {
//          int index = store.getCategoryIndex(MembersOrderPreferenceCache.STATIC_FIELDS_INDEX) * 2;
//          if (Modifier.isFinal(modifiers)) {
//            return index; // first final static, then static
//          }
//          return index + 1;
//        }
//        return store.getCategoryIndex(MembersOrderPreferenceCache.FIELDS_INDEX) * 2;
//      case DartNode.INITIALIZER:
//        if (Modifier.isStatic(modifiers)) {
//          return store.getCategoryIndex(MembersOrderPreferenceCache.STATIC_INIT_INDEX) * 2;
//        }
//        return store.getCategoryIndex(MembersOrderPreferenceCache.INIT_INDEX) * 2;
//      case DartNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
//        return store.getCategoryIndex(MembersOrderPreferenceCache.METHOD_INDEX) * 2;
//      case DartNode.METHOD_DECLARATION:
//        if (Modifier.isStatic(modifiers)) {
//          return store.getCategoryIndex(MembersOrderPreferenceCache.STATIC_METHODS_INDEX) * 2;
//        }
//        if (((MethodDeclaration) member).isConstructor()) {
//          return store.getCategoryIndex(MembersOrderPreferenceCache.CONSTRUCTORS_INDEX) * 2;
//        }
//        return store.getCategoryIndex(MembersOrderPreferenceCache.METHOD_INDEX) * 2;
//      default:
//        return 100;
//    }
//  }
//
//  /**
//   * Returns whether an expression at the given location needs explicit boxing.
//   * 
//   * @param expression the expression
//   * @return <code>true</code> iff an expression at the given location needs explicit boxing
//   */
//  private static boolean needsExplicitBoxing(Expression expression) {
//    StructuralPropertyDescriptor locationInParent = expression.getLocationInParent();
//    if (locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
//      return needsExplicitBoxing((ParenthesizedExpression) expression.getParent());
//    }
//
//    if (locationInParent == ClassInstanceCreation.EXPRESSION_PROPERTY
//        || locationInParent == FieldAccess.EXPRESSION_PROPERTY
//        || locationInParent == MethodInvocation.EXPRESSION_PROPERTY) {
//      return true;
//    }
//
//    return false;
//  }

  private ASTNodes() {
    // no instance;
  }

  /**
   * Looks to see if the property access requires a getter.
   * <p>
   * A property access requires a getter if it is on the right hand side of an assignment, or if it
   * is on the left hand side of an assignment and uses one of the assignment operators other than
   * plain '='.
   * <p>
   * Note, that we don't check if given {@link DartNode} is actually field name.
   */
  public static boolean inGetterContext(DartNode node) {
    if (node.getParent() instanceof DartBinaryExpression) {
      DartBinaryExpression expr = (DartBinaryExpression) node.getParent();
      if (expr.getArg1() == node && expr.getOperator() == Token.ASSIGN) {
        return false;
      }
    }
    return true;
  }

  /**
   * Looks to see if the property access requires a setter.
   * <p>
   * Basically, this boils down to any property access on the left hand side of an assignment.
   * <p>
   * Keep in mind that an assignment of the form node = <expr> is the only kind of write-only
   * expression. Other types of assignments also read the value and require a getter access.
   * <p>
   * Note, that we don't check if given {@link DartNode} is actually field name.
   */
  public static boolean inSetterContext(DartNode node) {
    if (node.getParent() instanceof DartUnaryExpression) {
      DartUnaryExpression expr = (DartUnaryExpression) node.getParent();
      return expr.getArg() == node && expr.getOperator().isCountOperator();
    }
    if (node.getParent() instanceof DartBinaryExpression) {
      DartBinaryExpression expr = (DartBinaryExpression) node.getParent();
      return expr.getArg1() == node && expr.getOperator().isAssignmentOperator();
    }
    return false;
  }

  /**
   * @return the {@link DartIdentifier} corresponding to the name of constructor.
   */
  public static DartIdentifier getConstructorNameNode(DartNewExpression node) {
    DartNode constructor = node.getConstructor();
    return getConstructorNameNode(constructor);
  }

  /**
   * @return the {@link DartIdentifier} corresponding to the name of constructor.
   */
  private static DartIdentifier getConstructorNameNode(DartNode constructor) {
    if (constructor instanceof DartPropertyAccess) {
      return ((DartPropertyAccess) constructor).getName();
    } else if (constructor instanceof DartTypeNode) {
      return getConstructorNameNode(((DartTypeNode) constructor).getIdentifier());
    } else {
      return (DartIdentifier) constructor;
    }
  }
  
  /**
   * @return <code>true</code> if given {@link DartNode} has {@link DartSuperExpression}.
   */
  public static boolean hasSuperInvocation(DartNode node) {
    final AtomicBoolean result = new AtomicBoolean();
    node.accept(new ASTVisitor<Void>() {
      @Override
      public Void visitSuperExpression(DartSuperExpression node) {
        result.set(true);
        return null;
      }
    });
    return result.get();
  }

}