* Copyright (c) 2013, 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.

*/

* Instances of the class {@code ElementResolver} are used by instances of {@link ResolverVisitor}

* to resolve references within the AST structure to the elements being referenced. The requirements

* for the element resolver are:

* <ol>

* <li>Every {@link SimpleIdentifier} should be resolved to the element to which it refers.

* Specifically:

* <ul>

* <li>An identifier within the declaration of that name should resolve to the element being

* declared.</li>

* <li>An identifier denoting a prefix should resolve to the element representing the import that

* defines the prefix (an {@link ImportElement}).</li>

* <li>An identifier denoting a variable should resolve to the element representing the variable (a

* {@link VariableElement}).</li>

* <li>An identifier denoting a parameter should resolve to the element representing the parameter

* (a {@link ParameterElement}).</li>

* <li>An identifier denoting a field should resolve to the element representing the getter or

* setter being invoked (a {@link PropertyAccessorElement}).</li>

* <li>An identifier denoting the name of a method or function being invoked should resolve to the

* element representing the method or function (a {@link ExecutableElement}).</li>

* <li>An identifier denoting a label should resolve to the element representing the label (a

* {@link LabelElement}).</li>

* </ul>

* The identifiers within directives are exceptions to this rule and are covered below.</li>

* <li>Every node containing a token representing an operator that can be overridden (

* {@link BinaryExpression}, {@link PrefixExpression}, {@link PostfixExpression}) should resolve to

* the element representing the method invoked by that operator (a {@link MethodElement}).</li>

* <li>Every {@link FunctionExpressionInvocation} should resolve to the element representing the

* function being invoked (a {@link FunctionElement}). This will be the same element as that to

* which the name is resolved if the function has a name, but is provided for those cases where an

* unnamed function is being invoked.</li>

* <li>Every {@link LibraryDirective} and {@link PartOfDirective} should resolve to the element

* representing the library being specified by the directive (a {@link LibraryElement}) unless, in

* the case of a part-of directive, the specified library does not exist.</li>

* <li>Every {@link ImportDirective} and {@link ExportDirective} should resolve to the element

* representing the library being specified by the directive unless the specified library does not

* exist (an {@link ImportElement} or {@link ExportElement}).</li>

* <li>The identifier representing the prefix in an {@link ImportDirective} should resolve to the

* element representing the prefix (a {@link PrefixElement}).</li>

* <li>The identifiers in the hide and show combinators in {@link ImportDirective}s and

* {@link ExportDirective}s should resolve to the elements that are being hidden or shown,

* respectively, unless those names are not defined in the specified library (or the specified

* library does not exist).</li>

* <li>Every {@link PartDirective} should resolve to the element representing the compilation unit

* being specified by the string unless the specified compilation unit does not exist (a

* {@link CompilationUnitElement}).</li>

* </ol>

* Note that AST nodes that would represent elements that are not defined are not resolved to

* anything. This includes such things as references to undeclared variables (which is an error) and

* names in hide and show combinators that are not defined in the imported library (which is not an

* error).

*

* @coverage dart.engine.resolver

*/

  /**

   * Instances of the class {@code SyntheticIdentifier} implement an identifier that can be used to

   * look up names in the lexical scope when there is no identifier in the AST structure. There is

   * no identifier in the AST when the parser could not distinguish between a method invocation and

   * an invocation of a top-level function imported with a prefix.

   */

  private static class SyntheticIdentifier extends Identifier {

    /**

     * The name of the synthetic identifier.

     */

    private final String name;

    /**

     * Initialize a newly created synthetic identifier to have the given name.

     *

     * @param name the name of the synthetic identifier

     */

    private SyntheticIdentifier(String name) {

      this.name = name;

    }

    @Override

    public <R> R accept(AstVisitor<R> visitor) {

      return null;

    }

    @Override

    public Token getBeginToken() {

      return null;

    }

    @Override

    public Element getBestElement() {

      return null;

    }

    @Override

    public Token getEndToken() {

      return null;

    }

    @Override

    public String getName() {

      return name;

    }

    @Override

    public int getPrecedence() {

      return 16;

    }

    @Override

    public Element getPropagatedElement() {

      return null;

    }

    @Override

    public Element getStaticElement() {

      return null;

    }

    @Override

    public void visitChildren(AstVisitor<?> visitor) {

    }

  }

  /**

   * Checks whether the given expression is a reference to a class. If it is then the

   * {@link ClassElement} is returned, otherwise {@code null} is returned.

   *

   * @param expression the expression to evaluate

   * @return the element representing the class

   */

  public static ClassElementImpl getTypeReference(Expression expression) {

    if (expression instanceof Identifier) {

      Element staticElement = ((Identifier) expression).getStaticElement();

      if (staticElement instanceof ClassElementImpl) {

        return (ClassElementImpl) staticElement;

      }

    }

    return null;

  }

  /**

   * Helper function for {@code maybeMergeExecutableElements} that does the actual merging.

   *

   * @param elementArrayToMerge non-empty array of elements to merge.

   * @return

   */

  private static ExecutableElement computeMergedExecutableElement(

      ExecutableElement[] elementArrayToMerge) {

    // Flatten methods structurally. Based on

    // [InheritanceManager.computeMergedExecutableElement] and

    // [InheritanceManager.createSyntheticExecutableElement].

    //

    // However, the approach we take here is much simpler, but expected to work

    // well in the common case. It degrades gracefully in the uncommon case,

    // by computing the type [dynamic] for the method, preventing any

    // hints from being generated (TODO: not done yet).

    //

    // The approach is: we require that each [ExecutableElement] has the

    // same shape: the same number of required, optional positional, and optional named

    // parameters, in the same positions, and with the named parameters in the

    // same order. We compute a type by unioning pointwise.

    ExecutableElement e_0 = elementArrayToMerge[0];

    ParameterElement[] ps_0 = e_0.getParameters();

    ParameterElementImpl[] ps_out = new ParameterElementImpl[ps_0.length];

    for (int j = 0; j < ps_out.length; j++) {

      ps_out[j] = new ParameterElementImpl(ps_0[j].getName(), 0);

      ps_out[j].setSynthetic(true);

      ps_out[j].setType(ps_0[j].getType());

      ps_out[j].setParameterKind(ps_0[j].getParameterKind());

    }

    Type r_out = e_0.getReturnType();

    for (int i = 1; i < elementArrayToMerge.length; i++) {

      ExecutableElement e_i = elementArrayToMerge[i];

      r_out = UnionTypeImpl.union(r_out, e_i.getReturnType());

      ParameterElement[] ps_i = e_i.getParameters();

      // Each function must have the same number of params.

      if (ps_0.length != ps_i.length) {

        return null; // TODO (collinsn): return an element representing [dynamic] here instead.

      } else {

        // Each function must have the same kind of params, with the same names,

        // in the same order.

        for (int j = 0; j < ps_i.length; j++) {

          if (ps_0[j].getParameterKind() != ps_i[j].getParameterKind()

              || ps_0[j].getName() != ps_i[j].getName()) {

            return null;

          } else {

            // The output parameter type is the union of the input parameter types.

            ps_out[j].setType(UnionTypeImpl.union(ps_out[j].getType(), ps_i[j].getType()));

          }

        }

      }

    }

    // TODO (collinsn): this code should work for functions and methods,

    // so we may want [FunctionElementImpl]

    // instead here in some cases? And then there are constructors and property accessors.

    // Maybe the answer is to create a new subclass of [ExecutableElementImpl] which

    // is used for merged executable elements, in analogy with [MultiplyInheritedMethodElementImpl]

    // and [MultiplyInheritedPropertyAcessorElementImpl].

    ExecutableElementImpl e_out = new MethodElementImpl(e_0.getName(), 0);

    e_out.setSynthetic(true);

    e_out.setReturnType(r_out);

    e_out.setParameters(ps_out);

    e_out.setType(new FunctionTypeImpl(e_out));

    // Get NPE in [toString()] w/o this.

    e_out.setEnclosingElement(e_0.getEnclosingElement());

    return e_out;

  }

  /**

   * Return {@code true} if the given identifier is the return type of a constructor declaration.

   *

   * @return {@code true} if the given identifier is the return type of a constructor declaration.

   */

  private static boolean isConstructorReturnType(SimpleIdentifier identifier) {

    AstNode parent = identifier.getParent();

    if (parent instanceof ConstructorDeclaration) {

      return ((ConstructorDeclaration) parent).getReturnType() == identifier;

    }

    return false;

  }

  /**

   * Return {@code true} if the given identifier is the return type of a factory constructor.

   *

   * @return {@code true} if the given identifier is the return type of a factory constructor

   *         declaration.

   */

  private static boolean isFactoryConstructorReturnType(SimpleIdentifier node) {

    AstNode parent = node.getParent();

    if (parent instanceof ConstructorDeclaration) {

      ConstructorDeclaration constructor = (ConstructorDeclaration) parent;

      return constructor.getReturnType() == node && constructor.getFactoryKeyword() != null;

    }

    return false;

  }

  /**

   * Return {@code true} if the given 'super' expression is used in a valid context.

   *

   * @param node the 'super' expression to analyze

   * @return {@code true} if the 'super' expression is in a valid context

   */

  private static boolean isSuperInValidContext(SuperExpression node) {

    for (AstNode n = node; n != null; n = n.getParent()) {

      if (n instanceof CompilationUnit) {

        return false;

      }

      if (n instanceof ConstructorDeclaration) {

        ConstructorDeclaration constructor = (ConstructorDeclaration) n;

        return constructor.getFactoryKeyword() == null;

      }

      if (n instanceof ConstructorFieldInitializer) {

        return false;

      }

      if (n instanceof MethodDeclaration) {

        MethodDeclaration method = (MethodDeclaration) n;

        return !method.isStatic();

      }

    }

    return false;

  }

  /**

   * Return a method representing the merge of the given elements. The type of the merged element is

   * the component-wise union of the types of the given elements. If not all input elements have the

   * same shape then [null] is returned.

   *

   * @param elements the {@code ExecutableElement}s to merge

   * @return an {@code ExecutableElement} representing the merge of {@code elements}

   */

  // TODO (collinsn): somehow return [dynamic] here, or at least in the callers, when not all

  // given methods have the same shape.

  private static ExecutableElement maybeMergeExecutableElements(Set<ExecutableElement> elements) {

    ExecutableElement[] elementArrayToMerge = elements.toArray(new ExecutableElement[elements.size()]);

    if (elementArrayToMerge.length == 0) {

      return null;

    } else if (elementArrayToMerge.length == 1) {

      // If all methods are equal, don't bother building a new one.

      return elementArrayToMerge[0];

    } else {

      return computeMergedExecutableElement(elementArrayToMerge);

    }

  }

  /**

   * The resolver driving this participant.

   */

  private ResolverVisitor resolver;

  /**

   * The element for the library containing the compilation unit being visited.

   */

  private LibraryElement definingLibrary;

  /**

   * A flag indicating whether we should generate hints.

   */

  private boolean enableHints;

  /**

   * The type representing the type 'dynamic'.

   */

  private Type dynamicType;

  /**

   * The type representing the type 'type'.

   */

  private Type typeType;

  /**

   * A utility class for the resolver to answer the question of "what are my subtypes?".

   */

  private SubtypeManager subtypeManager;

  /**

   * The object keeping track of which elements have had their types promoted.

   */

  private TypePromotionManager promoteManager;

  /**

   * Initialize a newly created visitor to resolve the nodes in a compilation unit.

   *

   * @param resolver the resolver driving this participant

   */

  public ElementResolver(ResolverVisitor resolver) {

    this.resolver = resolver;

    this.definingLibrary = resolver.getDefiningLibrary();

    AnalysisOptions options = definingLibrary.getContext().getAnalysisOptions();

    enableHints = options.getHint();

    dynamicType = resolver.getTypeProvider().getDynamicType();

    typeType = resolver.getTypeProvider().getTypeType();

    subtypeManager = new SubtypeManager();

    promoteManager = resolver.getPromoteManager();

  }

  @Override

  public Void visitAssignmentExpression(AssignmentExpression node) {

    Token operator = node.getOperator();

    TokenType operatorType = operator.getType();

    if (operatorType != TokenType.EQ) {

      operatorType = operatorFromCompoundAssignment(operatorType);

      Expression leftHandSide = node.getLeftHandSide();

      if (leftHandSide != null) {

        String methodName = operatorType.getLexeme();

        Type staticType = getStaticType(leftHandSide);

        MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);

        node.setStaticElement(staticMethod);

        Type propagatedType = getPropagatedType(leftHandSide);

        MethodElement propagatedMethod = lookUpMethod(leftHandSide, propagatedType, methodName);

        node.setPropagatedElement(propagatedMethod);

        if (shouldReportMissingMember(staticType, staticMethod)) {

          if (doesntHaveProxy(staticType.getElement())) {

            resolver.reportErrorForToken(

                StaticTypeWarningCode.UNDEFINED_METHOD,

                operator,

                methodName,

                staticType.getDisplayName());

          }

        } else if (enableHints && shouldReportMissingMember(propagatedType, propagatedMethod)

            && !memberFoundInSubclass(propagatedType.getElement(), methodName, true, false)) {

          if (doesntHaveProxy(propagatedType.getElement())) {

            resolver.reportErrorForToken(

                HintCode.UNDEFINED_METHOD,

                operator,

                methodName,

                propagatedType.getDisplayName());

          }

        }

      }

    }

    return null;

  }

  @Override

  public Void visitBinaryExpression(BinaryExpression node) {

    Token operator = node.getOperator();

    if (operator.isUserDefinableOperator()) {

      Expression leftOperand = node.getLeftOperand();

      if (leftOperand != null) {

        String methodName = operator.getLexeme();

        Type staticType = getStaticType(leftOperand);

        MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);

        node.setStaticElement(staticMethod);

        Type propagatedType = getPropagatedType(leftOperand);

        MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);

        node.setPropagatedElement(propagatedMethod);

        if (shouldReportMissingMember(staticType, staticMethod)) {

          if (doesntHaveProxy(staticType.getElement())) {

            resolver.reportErrorForToken(

                StaticTypeWarningCode.UNDEFINED_OPERATOR,

                operator,

                methodName,

                staticType.getDisplayName());

          }

        } else if (enableHints && shouldReportMissingMember(propagatedType, propagatedMethod)

            && !memberFoundInSubclass(propagatedType.getElement(), methodName, true, false)) {

          if (doesntHaveProxy(propagatedType.getElement())) {

            resolver.reportErrorForToken(

                HintCode.UNDEFINED_OPERATOR,

                operator,

                methodName,

                propagatedType.getDisplayName());

          }

        }

      }

    }

    return null;

  }

  @Override

  public Void visitBreakStatement(BreakStatement node) {

    lookupLabel(node, node.getLabel());

    return null;

  }

  @Override

  public Void visitClassDeclaration(ClassDeclaration node) {

    setMetadata(node.getElement(), node);

    return null;

  }

  @Override

  public Void visitClassTypeAlias(ClassTypeAlias node) {

    setMetadata(node.getElement(), node);

    return null;

  }

  @Override

  public Void visitCommentReference(CommentReference node) {

    Identifier identifier = node.getIdentifier();

    if (identifier instanceof SimpleIdentifier) {

      SimpleIdentifier simpleIdentifier = (SimpleIdentifier) identifier;

      Element element = resolveSimpleIdentifier(simpleIdentifier);

      if (element == null) {

        //

        // This might be a reference to an imported name that is missing the prefix.

        //

        element = findImportWithoutPrefix(simpleIdentifier);

        if (element instanceof MultiplyDefinedElement) {

          // TODO(brianwilkerson) Report this error?

          element = null;

        }

      }

      if (element == null) {

        // TODO(brianwilkerson) Report this error?

//        resolver.reportError(

//            StaticWarningCode.UNDEFINED_IDENTIFIER,

//            simpleIdentifier,

//            simpleIdentifier.getName());

      } else {

        if (element.getLibrary() == null || !element.getLibrary().equals(definingLibrary)) {

          // TODO(brianwilkerson) Report this error?

        }