// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

package com.google.dart.compiler.resolver;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Objects;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.dart.compiler.DartSource;
import com.google.dart.compiler.LibrarySource;
import com.google.dart.compiler.Source;
import com.google.dart.compiler.ast.DartClass;
import com.google.dart.compiler.ast.DartClassMember;
import com.google.dart.compiler.ast.DartField;
import com.google.dart.compiler.ast.DartFunctionExpression;
import com.google.dart.compiler.ast.DartFunctionTypeAlias;
import com.google.dart.compiler.ast.DartIdentifier;
import com.google.dart.compiler.ast.DartLabel;
import com.google.dart.compiler.ast.DartMethodDefinition;
import com.google.dart.compiler.ast.DartNativeBlock;
import com.google.dart.compiler.ast.DartNode;
import com.google.dart.compiler.ast.DartObsoleteMetadata;
import com.google.dart.compiler.ast.DartParameter;
import com.google.dart.compiler.ast.DartSuperExpression;
import com.google.dart.compiler.ast.DartTypeNode;
import com.google.dart.compiler.ast.DartTypeParameter;
import com.google.dart.compiler.ast.DartVariable;
import com.google.dart.compiler.ast.LibraryUnit;
import com.google.dart.compiler.ast.Modifiers;
import com.google.dart.compiler.common.SourceInfo;
import com.google.dart.compiler.resolver.LabelElement.LabeledStatementType;
import com.google.dart.compiler.type.InterfaceType;
import com.google.dart.compiler.type.InterfaceType.Member;
import com.google.dart.compiler.type.Type;
import com.google.dart.compiler.type.TypeVariable;
import com.google.dart.compiler.util.Paths;
import com.google.dart.compiler.util.apache.StringUtils;

import java.io.File;
import java.net.URI;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

/**
 * Utility and factory methods for elements.
 */
public class Elements {

  private Elements() {} // Prevent subclassing and instantiation.

  static void setParameterInitializerElement(VariableElement varElement, FieldElement element) {
    ((VariableElementImplementation) varElement).setParameterInitializerElement(element);
  }

  static void setDefaultClass(ClassElement classElement, InterfaceType defaultClass) {
    ((ClassElementImplementation) classElement).setDefaultClass(defaultClass);
  }

  static void addInterface(ClassElement classElement, InterfaceType type) {
    ((ClassElementImplementation) classElement).addInterface(type);
  }

  static LabelElement statementLabelElement(DartLabel node, String name,
      MethodElement enclosingFunction) {
    return new LabelElementImplementation(node, name, enclosingFunction,
        LabeledStatementType.STATEMENT);
  }

  static LabelElement switchMemberLabelElement(DartLabel node, String name,
      MethodElement enclosingFunction) {
    return new LabelElementImplementation(node, name, enclosingFunction,
        LabeledStatementType.SWITCH_MEMBER_STATEMENT);
  }

  static LabelElement switchLabelElement(DartLabel node, String name,
      MethodElement enclosingFunction) {
    return new LabelElementImplementation(node, name, enclosingFunction,
        LabeledStatementType.SWITCH_STATEMENT);
  }

  public static LibraryElement libraryElement(LibraryUnit libraryUnit) {
    return new LibraryElementImplementation(libraryUnit);
  }
  
  public static void setLibraryMetadata(LibraryElement element, DartObsoleteMetadata metadata) {
    ((LibraryElementImplementation) element).setMetadata(metadata);
  }
  
  public static Element addExportedElement(LibraryElement libraryElement, Element element) {
    return ((LibraryElementImplementation) libraryElement).addExportedElements(element);
  }

  public static LibraryElement getLibraryElement(Element element) {
    while (element != null) {
      if (ElementKind.of(element) == ElementKind.LIBRARY) {
        return (LibraryElement) element;
      }
      EnclosingElement enclosingElement = element.getEnclosingElement();
      if (enclosingElement == element) {
        return null;
      }
      element = enclosingElement;
    };
    return null;
  }
  
  /**
   * @return <code>true</code> if "a" and "b" are declared in the same {@link LibraryElement}.
   */
  public static boolean areSameLibrary(Element a, Element b) {
    LibraryElement aLibrary = getLibraryElement(a);
    LibraryElement bLibrary = getLibraryElement(b);
    return Objects.equal(aLibrary, bLibrary);
  }

  @VisibleForTesting
  public static MethodElement methodElement(DartFunctionExpression node, String name) {
    return new MethodElementImplementation(node, name, Modifiers.NONE);
  }

  public static TypeVariableElement typeVariableElement(String name, Type bound) {
    return new TypeVariableElementImplementation(name, bound);
  }

  public static VariableElement variableElement(EnclosingElement owner,
      DartVariable node,
      String name,
      Modifiers modifiers) {
    return new VariableElementImplementation(owner,
        node,
        node.getName().getSourceInfo(),
        name,
        ElementKind.VARIABLE,
        modifiers,
        false,
        null);
  }

  public static VariableElement parameterElement(EnclosingElement owner,
      DartParameter node,
      String name,
      Modifiers modifiers) {
    return new VariableElementImplementation(owner,
        node,
        node.getName().getSourceInfo(),
        name,
        ElementKind.PARAMETER,
        modifiers,
        node.getModifiers().isNamed(),
        node.getDefaultExpr());
  }

  public static SuperElement superElement(DartSuperExpression node, ClassElement cls) {
    return new SuperElementImplementation(node, cls);
  }

  static void addConstructor(ClassElement cls, ConstructorNodeElement constructor) {
    ((ClassElementImplementation) cls).addConstructor(constructor);
  }

  static void addField(EnclosingElement holder, FieldNodeElement field) {
    if (ElementKind.of(holder).equals(ElementKind.CLASS)) {
      ((ClassElementImplementation) holder).addField(field);
    } else if (ElementKind.of(holder).equals(ElementKind.LIBRARY)) {
      ((LibraryElementImplementation) holder).addField(field);
    } else {
      throw new IllegalArgumentException();
    }
  }

  @VisibleForTesting
  public static void addMethod(EnclosingElement holder, MethodNodeElement method) {
    if (ElementKind.of(holder).equals(ElementKind.CLASS)) {
      ((ClassElementImplementation) holder).addMethod(method);
    } else if (ElementKind.of(holder).equals(ElementKind.LIBRARY)) {
      ((LibraryElementImplementation) holder).addMethod(method);
    } else {
      throw new IllegalArgumentException();
    }
  }

  public static void addParameter(MethodElement method, VariableElement parameter) {
    ((MethodElementImplementation) method).addParameter(parameter);
  }

  static Element findElement(EnclosingElement cls, String name) {
    if (cls instanceof  ClassElementImplementation) {
      return ((ClassElementImplementation) cls).findElement(name);
    }
    return null;
  }

  public static MethodElement methodFromFunctionExpression(DartFunctionExpression node,
                                                           Modifiers modifiers) {
    return MethodElementImplementation.fromFunctionExpression(node, modifiers);
  }

  public static MethodNodeElement methodFromMethodNode(DartMethodDefinition node,
      EnclosingElement holder) {
    return MethodElementImplementation.fromMethodNode(node, holder);
  }

  static ConstructorNodeElement constructorFromMethodNode(DartMethodDefinition node,
                                                      String name,
                                                      ClassElement declaringClass,
                                                      ClassElement constructorType) {
    return ConstructorElementImplementation.fromMethodNode(node, name, declaringClass,
                                                           constructorType);
  }

  public static void setType(Element element, Type type) {
    ((AbstractNodeElement) element).setType(type);
  }

  public static void setOverridden(Element element, Set<Element> overridden) {
    if (element instanceof MethodElementImplementation) {
      ((MethodElementImplementation) element).setOverridden(overridden);
    }
    if (element instanceof FieldElementImplementation) {
      ((FieldElementImplementation) element).setOverridden(overridden);
    }
  }

static FieldElementImplementation fieldFromNode(DartField node,
                                                  EnclosingElement holder,
                                                  DartObsoleteMetadata metadata,
                                                  Modifiers modifiers) {
    return FieldElementImplementation.fromNode(node, holder, metadata, modifiers);
  }

  static ClassElement classFromNode(DartClass node, LibraryElement library) {
    return ClassElementImplementation.fromNode(node, library);
  }

  public static ClassElement classNamed(String name) {
    return ClassElementImplementation.named(name);
  }

  static TypeVariableElement typeVariableFromNode(DartTypeParameter node, EnclosingElement element) {
    return TypeVariableElementImplementation.fromNode(node, element);
  }

  public static DynamicElement dynamicElement() {
    return DynamicElementImplementation.getInstance();
  }

  static ConstructorElement lookupConstructor(ClassElement cls, ClassElement type, String name) {
    return ((ClassElementImplementation) cls).lookupConstructor(type, name);
  }

  static ConstructorElement lookupConstructor(ClassElement cls, String name) {
    if (cls instanceof  ClassElementImplementation) {
      return ((ClassElementImplementation) cls).lookupConstructor(name);
    }
    return null;
  }

  public static MethodElement lookupLocalMethod(ClassElement cls, String name) {
    return ((ClassElementImplementation) cls).lookupLocalMethod(name);
  }

  public static FieldElement lookupLocalField(ClassElement cls, String name) {
    return ((ClassElementImplementation) cls).lookupLocalField(name);
  }

  public static FunctionAliasElement functionTypeAliasFromNode(DartFunctionTypeAlias node,
                                                               LibraryElement library) {
    return FunctionAliasElementImplementation.fromNode(node, library);
  }

  /**
   * @return <code>true</code> if given {@link Element} represents {@link VariableElement} for
   *         parameter in {@link DartMethodDefinition}.
   */
  public static boolean isConstructorParameter(Element element) {
    Element parent = element.getEnclosingElement();
    if (parent instanceof MethodElement) {
      return ((MethodElement) parent).isConstructor();
    }
    return false;
  }

  /**
   * @return <code>true</code> if given {@link Element} represents {@link VariableElement} for
   *         parameter in {@link DartMethodDefinition} without body, or with {@link DartNativeBlock}
   *         as body.
   */
  public static boolean isParameterOfMethodWithoutBody(Element element) {
    if (element instanceof VariableElement) {
      Element parent = element.getEnclosingElement();
      if (parent instanceof MethodElement) {
        MethodElement parentMethod = (MethodElement) parent;
        return !parentMethod.hasBody();
      }
    }
    return false;
  }

  /**
   * @return <code>non-null</code>  {@link MethodElement} if "holder", or one of its
   *         interfaces, or its superclass has {@link FieldElement} with getter.
   */
  public static MethodElement lookupFieldElementGetter(EnclosingElement holder, String name) {
    Element element = holder.lookupLocalElement(name);
    if (element instanceof FieldElement) {
      FieldElement fieldElement = (FieldElement) element;
      MethodElement result = fieldElement.getGetter();
      if (result != null) {
        return fieldElement.getGetter();
      }
    }
    if (holder instanceof ClassElement) {
      ClassElement classHolder = (ClassElement) holder;
      for (InterfaceType interfaceType : classHolder.getInterfaces()) {
        MethodElement result = lookupFieldElementGetter(interfaceType.getElement(), name);
        if (result != null) {
          return result;
        }
      }
      if (classHolder.getSupertype() != null) {
        MethodElement result = lookupFieldElementGetter(classHolder.getSupertype().getElement(),
            name);
        if (result != null) {
          return result;
        }
      }
    }

    return null;
  }

  /**
   * @return <code>non-null</code> {@link MethodElement} if "holder", or one of its interfaces,
   *         or its superclass has {@link FieldElement} with setter.
   */
  public static MethodElement lookupFieldElementSetter(EnclosingElement holder, String name) {
    Element element = holder.lookupLocalElement(name);
    if (element instanceof FieldElement) {
      FieldElement fieldElement = (FieldElement) element;
      MethodElement result = fieldElement.getSetter();
      if (result != null) {
        return result;
      }
    }
    if (holder instanceof ClassElement) {
      ClassElement classHolder = (ClassElement)holder;
      for (InterfaceType interfaceType : classHolder.getInterfaces()) {
        MethodElement result = lookupFieldElementSetter(interfaceType.getElement(), name);
        if (result != null) {
          return result;
        }
      }
      if (classHolder.getSupertype() != null) {
        MethodElement result = lookupFieldElementSetter(classHolder.getSupertype().getElement(),
            name);
        if (result != null) {
          return result;
        }
      }
    }
    return null;
  }

  /**
   * @return <code>true</code> if {@link DartNode} of given {@link Element} if part of static
   *         {@link DartClassMember} or part of top level declaration.
   */
  public static boolean isStaticContext(Element element) {
    if (element instanceof ClassElement) {
      return true;
    }
    while (element != null) {
      if (element instanceof MethodElement) {
        MethodElement methodElement = (MethodElement) element;
        return methodElement.isStatic() || methodElement.getEnclosingElement()  instanceof LibraryElement;
      }
      if (element instanceof FieldElement) {
        FieldElement fieldElement = (FieldElement) element;
        return fieldElement.isStatic()
            || fieldElement.getEnclosingElement() instanceof LibraryElement;
      }
      if (element instanceof ClassElement) {
        return false;
      }
      element = element.getEnclosingElement();
    }
    return true;
  }

  public static boolean isNonFactoryConstructor(Element method) {
    return !method.getModifiers().isFactory()
        && ElementKind.of(method) == ElementKind.CONSTRUCTOR;
  }

  public static boolean isTopLevel(Element element) {
    return ElementKind.of(element.getEnclosingElement()) == ElementKind.LIBRARY;
  }

  static List<TypeVariable> makeTypeVariables(List<DartTypeParameter> parameterNodes,
                                              EnclosingElement enclosingElement) {
    if (parameterNodes == null) {
      return Arrays.<TypeVariable>asList();
    }
    TypeVariable[] typeVariables = new TypeVariable[parameterNodes.size()];
    int i = 0;
    for (DartTypeParameter parameterNode : parameterNodes) {
      TypeVariable typeVariable =
          Elements.typeVariableFromNode(parameterNode, enclosingElement).getTypeVariable();
      typeVariables[i++] = typeVariable;
      parameterNode.getName().setElement(typeVariable.getElement());
    }
    return Arrays.asList(typeVariables);
  }

  public static Element voidElement() {
    return VoidElement.getInstance();
  }

  /**
   * Returns true if the class needs an implicit default constructor.
   */
  public static boolean needsImplicitDefaultConstructor(ClassElement classElement) {
    return classElement.getConstructors().isEmpty()
        && (!classElement.isInterface() || classElement.getDefaultClass() != null);
  }

  /**
   * @return <code>true</code> if {@link #classElement} implements {@link #interfaceElement}.
   */
  public static boolean implementsType(ClassElement classElement, ClassElement interfaceElement) {
    try {
      for (InterfaceType supertype : classElement.getAllSupertypes()) {
        if (supertype.getElement().equals(interfaceElement)) {
          return true;
        }
      }
    } catch (Throwable e) {
    }
    return false;
  }

  /**
   * @return the "name" or "qualifier.name" raw name of {@link DartMethodDefinition} which
   *         corresponds the given {@link MethodElement}.
   */
  public static String getRawMethodName(MethodElement methodElement) {
    if (methodElement instanceof ConstructorElement) {
      ConstructorElement constructorElement = (ConstructorElement) methodElement;
      return constructorElement.getRawName();
    }
    return methodElement.getName();
  }

  /**
   * @return the number of required (not optional/named) parameters in given {@link MethodElement}.
   */
  public static int getNumberOfRequiredParameters(MethodElement method) {
    int num = 0;
    List<VariableElement> parameters = method.getParameters();
    for (VariableElement parameter : parameters) {
      if (!parameter.isOptional() && !parameter.isNamed()) {
        num++;
      }
    }
    return num;
  }
  
  /**
   * @return the number of optional positional parameters in given {@link MethodElement}.
   */
  public static int getNumberOfOptionalPositionalParameters(MethodElement method) {
    int num = 0;
    List<VariableElement> parameters = method.getParameters();
    for (VariableElement parameter : parameters) {
      if (parameter.isOptional()) {
        num++;
      }
    }
    return num;
  }

  /**
   * @return the names for named parameters in given {@link MethodElement}.
   */
  public static List<String> getNamedParameters(MethodElement method) {
    List<String> names = Lists.newArrayList();
    List<VariableElement> parameters = method.getParameters();
    for (VariableElement parameter : parameters) {
      if (parameter.isNamed()) {
        names.add(parameter.getName());
      }
    }
    return names;
  }

  /**
   * @return the names for parameters types in given {@link MethodElement}.
   */
  public static List<String> getParameterTypeNames(MethodElement method) {
    List<String> names = Lists.newArrayList();
    List<VariableElement> parameters = method.getParameters();
    for (VariableElement parameter : parameters) {
      String typeName = parameter.getType().getElement().getName();
      names.add(typeName);
    }
    return names;
  }
  
  /**
   * Prepares title for {@link TypeErrorCode#DEPRECATED_ELEMENT}.
   */
  public static String getDeprecatedElementTitle(Element element) {
    String title = getUserElementTitle(element);
    return StringUtils.capitalize(title);
  }

  /**
   * @return the user readable title of the given {@link Element}, a little different than
   *         "technical" title returned from {@link Element#toString()}.
   */
  public static String getUserElementTitle(Element element) {
    return MessageFormat.format("{0} ''{1}''", getUserElementKindTitle(element), element.getName());
  }

  /**
   * @return the user readable title of the given {@link Element}'s {@link ElementKind}, a little
   *         different than "technical" title returned from {@link Element#toString()}.
   */
  private static String getUserElementKindTitle(Element element) {
    ElementKind kind = element.getKind();
    switch (kind) {
      case CLASS:
        if (((ClassElement) element).isInterface()) {
          return "interface";
        }
        break;
      case METHOD:
        if (isTopLevel(element)) {
          return "top-level function";
        }
        break;
      case FIELD:
        if (isTopLevel(element)) {
          return "top-level variable";
        }
        break;
    }
    String title = kind.toString();
    title = StringUtils.replace(title, "_", " ");
    title = title.toLowerCase();
    return title;
  }

  /**
   * @return the {@link String} which contains user-readable description of "target" {@link Element}
   *         location relative to "source".
   */
  public static String getRelativeElementLocation(Element source, Element target) {
    // Prepare "target" SourceInfo.
    SourceInfo targetInfo;
    {
      targetInfo = target.getNameLocation();
      if (targetInfo == null) {
        return "unknown";
      }
    }
    // Prepare path to the target unit from source unit.
    String targetPath;
    {
      SourceInfo sourceInfo = source.getSourceInfo();
      targetPath = getRelativeSourcePath(sourceInfo, targetInfo);
    }
    // Prepare (may be empty) target class name.
    String targetClassName;
    {
      EnclosingElement targetEnclosing = target.getEnclosingElement();
      ClassElement targetClass = getEnclosingClassElement(targetEnclosing);
      targetClassName = targetClass != null ? targetClass.getName() : "";
    }
    // Format location string.
    if (StringUtils.isEmpty(targetClassName)) {
      return MessageFormat.format("{0} line:{1} col:{2}", targetPath, targetInfo.getLine(),
          targetInfo.getColumn());
    } else {
      return MessageFormat.format("{0} class:{1} line:{2} col:{3}", targetPath, targetClassName,
          targetInfo.getLine(), targetInfo.getColumn());
    }
  }

  /**
   * @return the relative or absolute path from "source" to "target".
   */
  private static String getRelativeSourcePath(SourceInfo source, SourceInfo target) {
    Source sourceSource = source.getSource();
    Source targetSource = target.getSource();
    return getRelativeSourcePath(sourceSource, targetSource);
  }

  /**
   * @return the relative or absolute path from "source" to "target".
   */
  public static String getRelativeSourcePath(Source sourceSource, Source targetSource) {
    // If both source are from file, prepare relative path.
    if (sourceSource != null && targetSource != null) {
      URI sourceUri = sourceSource.getUri();
      URI targetUri = targetSource.getUri();
      if (Objects.equal(sourceUri.getScheme(), "file")
          && Objects.equal(targetUri.getScheme(), "file")) {
        return Paths.relativePathFor(new File(sourceUri.getPath()), new File(targetUri.getPath()));
      }
    }
    // Else return absolute path (including dart:// protocol).
    if (targetSource != null) {
      URI targetUri = targetSource.getUri();
      return targetUri.toString();
    }
    // No source for target.
    return "<unknown>";
  }

  /**
   * @return the full location of the given {@link Element} - library and unit.
   */
  public static String getLibraryUnitLocation(Element element) {
    try {
      StringBuilder sb = new StringBuilder();
      // library URI
      String libraryUri;
      {
        LibraryUnit libraryUnit = getDeclaringLibrary(element).getLibraryUnit();
        libraryUri = libraryUnit.getSource().getUri().toString();
        sb.append(libraryUri);
      }
      // unit URI
      SourceInfo sourceInfo = element.getSourceInfo();
      {
        String unitUri = sourceInfo.getSource().getUri().toString();
        if (!unitUri.equals(libraryUri)) {
          sb.append(" ");
          sb.append(unitUri);
        }
      }
      // line
      sb.append(":");
      sb.append(sourceInfo.getLine());
      // done
      return sb.toString();
    } catch (Throwable e) {
      return "<exception>";
    }
  }

  /**
   * @return the enclosing {@link ClassElement} (may be same if already given {@link ClassElement}),
   *         may be <code>null</code> if top level element.
   */
  public static ClassElement getEnclosingClassElement(Element element) {
    while (element != null) {
      if (element instanceof ClassElement) {
        return (ClassElement) element;
      }
      element = element.getEnclosingElement();
    }
    return null;
  }

  /**
   * @return <code>true</code> if the given {@link DartTypeNode} is type with one of the given
   *         names.
   */
  public static boolean isTypeNode(DartTypeNode typeNode, Set<String> names) {
    if (typeNode != null) {
      DartNode identifier = typeNode.getIdentifier();
      String typeName = getIdentifierName(identifier);
      return names.contains(typeName);
    }
    return false;
  }

  /**
   * @return <code>true</code> if the given {@link DartTypeNode} is type with given name.
   */
  public static boolean isTypeNode(DartTypeNode typeNode, String name) {
    return typeNode != null && isIdentifierName(typeNode.getIdentifier(), name);
  }

  /**
   * @return <code>true</code> if the given {@link DartNode} is type identifier with given name.
   */
  public static boolean isIdentifierName(DartNode identifier, String name) {
    String identifierName = getIdentifierName(identifier);
    return Objects.equal(identifierName, name);
  }

  /**
   * @return <code>true</code> if the given {@link ConstructorElement} is a synthetic default
   *         constructor.
   */
  public static boolean isSyntheticConstructor(ConstructorElement element) {
    return element != null && element.isSynthetic();
  }

  /**
   * @return <code>true</code> if the given {@link ConstructorElement} is a default constructor.
   */
  public static boolean isDefaultConstructor(ConstructorElement element) {
    return element != null
        && element.getParameters().isEmpty()
        && getRawMethodName(element).equals(element.getEnclosingElement().getName());
  }
  
  public static void setRedirectingFactoryConstructor(ConstructorElement source,
      ConstructorElement target) {
    ((ConstructorElementImplementation) source).setRedirectingFactoryConstructor(target);
  }

  /**
   * @return the name of given {@link DartNode} if it is {@link DartIdentifier}, or
   *         <code>null</code> otherwise.
   */
  private static String getIdentifierName(DartNode identifier) {
    if (identifier != null && identifier instanceof DartIdentifier) {
      return ((DartIdentifier) identifier).getName();
    }
    return null;
  }

  /**
   * @return <code>true</code> if given {@link Source} represents library with given name.
   */
  public static boolean isLibrarySource(Source source, String name) {
    LibrarySource library = null;
    if (source instanceof LibrarySource) {
      library = (LibrarySource) source;
    }
    if (source instanceof DartSource) {
      DartSource dartSource = (DartSource) source;
      library = dartSource.getLibrary();
    }
    if (library != null) {
      String libraryName = library.getName();
      return libraryName.endsWith(name);
    }
    return false;
  }

  /**
   * @return <code>true</code> if given {@link Source} represents code library declaration or
   *         implementation.
   */
  public static boolean isCoreLibrarySource(Source source) {
    if (source != null && source.getUri() != null
        && source.getUri().toString().equals("libraries.dart")) {
      return true;
    }
    // TODO (danrubel) remove these when dartc libraries are removed
    // Old core library file names
    return Elements.isLibrarySource(source, "/core/corelib.dart")
        || Elements.isLibrarySource(source, "/core/corelib_impl.dart")
        // New core library file names
        || Elements.isLibrarySource(source, "/core/core.dart");
  }
  
  public static boolean isCollectionLibrarySource(Source source) {
    return Elements.isLibrarySource(source, "/collection/collection.dart");
  }
  
  public static boolean isHtmlLibrarySource(Source source) {
    return Elements.isLibrarySource(source, "/html/dartium/html_dartium.dart");
  }
  
  public static boolean isSourceName(Source source, String requiredName) {
    return source.getName().equals(requiredName);
  }

  /**
   * @return the {@link LibraryElement} which declares given {@link Element}.
   */
  public static LibraryElement getDeclaringLibrary(Element element) {
    while (element != null) {
      if (element instanceof LibraryElement) {
        return (LibraryElement) element;
      }
      element = element.getEnclosingElement();
    }
    return null;
  }

  /**
   * @return <code>true</code> if "element" is accessible in "scopeLibrary".
   */
  public static boolean isAccessible(LibraryElement scopeLibrary, Element element) {
    if (element != null && StringUtils.startsWith(element.getName(), "_")) {
      return Objects.equal(scopeLibrary, getDeclaringLibrary(element));
    }
    return true;
  }

  /**
   * @return <code>true</code> if given {@link Element} if {@link MethodElement} for
   *         function "identical".
   */
  public static boolean isFunctionIdentical(Element element) {
    if (element instanceof MethodElement) {
      MethodElement methodElement = (MethodElement) element;
      return Objects.equal(methodElement.getName(), "identical")
          && methodElement.getEnclosingElement() instanceof LibraryElement
          && methodElement.getEnclosingElement().getName().equals("dart://core/core.dart");
    }
    return false;
  }

  /**
   * @return <code>true</code> if normal field or abstract field with getter.
   */
  public static boolean isFieldWithGetter(FieldElement fieldElement) {
    if (fieldElement.getModifiers().isAbstractField()) {
      return fieldElement.getGetter() != null;
    }
    return true;
  }
  
  public static boolean isAbstractFieldWithoutGetter(Element element) {
    if (element instanceof FieldElement) {
      FieldElement fieldElement = (FieldElement) element;
      return fieldElement.getModifiers().isAbstractField() && fieldElement.getGetter() == null;
    }
    return false;
  }

  public static boolean hasClassMember(ClassElement clazz, String name) {
    if (clazz.lookupLocalElement(name) != null) {
      return true;
    }
    for (InterfaceType interfaceType : clazz.getInterfaces()) {
      if (hasClassMember(interfaceType.getElement(), name)) {
        return true;
      }
    }
    if (clazz.getSupertype() != null) {
      if (hasClassMember(clazz.getSupertype().getElement(), name)) {
        return true;
      }
    }
    return false;
  }
  
  /**
   * @return <code>true</code> if given {@link FieldElement} is explicitly declared static, or is
   *         static implicitly.
   */
  public static boolean isStaticField(FieldElement field) {
    Modifiers modifiers = field.getModifiers();
    return modifiers.isStatic();
  }

  /**
   * @return <code>true</code> if given {@link InterfaceType} overrides "noSuchMethod".
   */
  public static boolean handlesNoSuchMethod(InterfaceType type) {
    Member member = type.lookupMember("noSuchMethod");
    if (member == null) {
      return false;
    }
    Source source = member.getElement().getSourceInfo().getSource();
    return !isCoreLibrarySource(source);
  }
  
  public static DuplicateElement createDuplicateElement(Element oldElement, Element newElement) {
    return new DuplicateElementImplementation(oldElement, newElement);
  }
  
  
  public static List<Element> getAllMembers(ClassElement classElement) {
    List<Element> allMembers = Lists.newArrayList();
    Set<ClassElement> visited = Sets.newHashSet();
    addAllMembers(visited, allMembers, classElement);
    return allMembers;
  }
  
  private static void addAllMembers(Set<ClassElement> visited, List<Element> allMembers, ClassElement classElement) {
    if (classElement == null) {
      return;
    }
    if (visited.contains(classElement)) {
      return;
    }
    visited.add(classElement);
    Iterables.addAll(allMembers, classElement.getMembers());
    {
      InterfaceType superType = classElement.getSupertype();
      if (superType != null)
        addAllMembers(visited, allMembers, superType.getElement());
    }
    for (InterfaceType intf : classElement.getInterfaces()) {
      addAllMembers(visited, allMembers, intf.getElement());
    }
  }
  
  public static boolean isAbstractElement(Element element) {
    if (element == null) {
      return false;
    }
    if (element.getModifiers().isAbstract()) {
      return true;
    }
    if (element.getModifiers().isExternal()) {
      return false;
    }
    if (element.getModifiers().isStatic()) {
      return false;
    }
    if (ElementKind.of(element) == ElementKind.METHOD) {
      MethodElement method = (MethodElement) element;
      return !method.hasBody();
    }
    if (ElementKind.of(element) == ElementKind.FIELD) {
      FieldElement field = (FieldElement) element;
      if (isAbstractElement(field.getGetter())) {
        return true;
      }
      if (isAbstractElement(field.getSetter())) {
        return true;
      }
      return false;
    }
    return false;
  }
}