// Copyright (c) 2015, 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.

part of dart2js.semantics_visitor;

enum SendStructureKind {
  GET,
  SET,
  INVOKE,
  UNARY,
  NOT,
  BINARY,
  EQ,
  NOT_EQ,
  COMPOUND,
  INDEX,
  INDEX_SET,
  COMPOUND_INDEX_SET,
  PREFIX,
  POSTFIX,
  INDEX_PREFIX,
  INDEX_POSTFIX,
}

abstract class SendResolverMixin {
  TreeElements get elements;

  internalError(Spannable spannable, String message);

  AccessSemantics handleCompoundErroneousSetterAccess(
      Send node,
      Element setter,
      Element getter) {
    assert(invariant(node, Elements.isUnresolved(setter),
        message: "Unexpected erreneous compound setter: $setter."));
    if (getter.isStatic) {
      if (getter.isGetter) {
        return new CompoundAccessSemantics(
            CompoundAccessKind.UNRESOLVED_STATIC_SETTER, getter, setter);
      } else if (getter.isField) {
        // TODO(johnniwinther): Handle const field separately.
        assert(invariant(node, getter.isFinal || getter.isConst,
            message: "Field expected to be final or const."));
        return new StaticAccess.finalStaticField(getter);
      } else if (getter.isFunction) {
        return new StaticAccess.staticMethod(getter);
      } else {
        return internalError(node,
            "Unexpected erroneous static compound: getter=$getter");
      }
    } else if (getter.isTopLevel) {
      if (getter.isGetter) {
        return new CompoundAccessSemantics(
            CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER, getter, setter);
      } else if (getter.isField) {
        // TODO(johnniwinther): Handle const field separately.
        assert(invariant(node, getter.isFinal || getter.isConst,
            message: "Field expected to be final or const."));
        return new StaticAccess.finalTopLevelField(getter);
      } else if (getter.isFunction) {
        return new StaticAccess.topLevelMethod(getter);
      } else {
        return internalError(node,
            "Unexpected erroneous top level compound: getter=$getter");
      }
    } else if (getter.isParameter) {
      assert(invariant(node, getter.isFinal,
          message: "Parameter expected to be final."));
      return new StaticAccess.finalParameter(getter);
    } else if (getter.isLocal) {
      if (getter.isVariable) {
        // TODO(johnniwinther): Handle const variable separately.
        assert(invariant(node, getter.isFinal || getter.isConst,
            message: "Variable expected to be final or const."));
        return new StaticAccess.finalLocalVariable(getter);
      } else if (getter.isFunction) {
        return new StaticAccess.localFunction(getter);
      } else {
        return internalError(node,
            "Unexpected erroneous local compound: getter=$getter");
      }
    } else if (getter.isErroneous) {
      return new StaticAccess.unresolved(getter);
    } else {
      return internalError(node,
          "Unexpected erroneous compound: getter=$getter");
    }
  }

  AccessSemantics handleStaticallyResolvedAccess(
      Send node,
      Element element,
      Element getter,
      {bool isCompound}) {
    if (element == null) {
      assert(invariant(node, isCompound, message:
        "Non-compound static access without element."));
      assert(invariant(node, getter != null, message:
        "Compound static access without element."));
      return handleCompoundErroneousSetterAccess(node, element, getter);
    }
    if (element.isErroneous) {
      if (isCompound) {
        return handleCompoundErroneousSetterAccess(node, element, getter);
      }
      return new StaticAccess.unresolved(element);
    } else if (element.isParameter) {
      if (element.isFinal) {
        return new StaticAccess.finalParameter(element);
      } else {
        return new StaticAccess.parameter(element);
      }
    } else if (element.isLocal) {
      if (element.isFunction) {
        return new StaticAccess.localFunction(element);
      } else if (element.isFinal || element.isConst) {
        return new StaticAccess.finalLocalVariable(element);
      } else {
        return new StaticAccess.localVariable(element);
      }
    } else if (element.isStatic) {
      if (element.isField) {
        if (element.isFinal || element.isConst) {
          // TODO(johnniwinther): Handle const field separately.
          return new StaticAccess.finalStaticField(element);
        }
        return new StaticAccess.staticField(element);
      } else if (element.isGetter) {
        if (isCompound) {
          return new CompoundAccessSemantics(
              CompoundAccessKind.UNRESOLVED_STATIC_SETTER, element, null);
        }
        return new StaticAccess.staticGetter(element);
      } else if (element.isSetter) {
        if (getter != null) {
          CompoundAccessKind accessKind;
          if (getter.isErroneous) {
            accessKind = CompoundAccessKind.UNRESOLVED_STATIC_GETTER;
          } else if (getter.isAbstractField) {
            AbstractFieldElement abstractField = getter;
            if (abstractField.getter == null) {
              accessKind = CompoundAccessKind.UNRESOLVED_STATIC_GETTER;
            } else {
              // TODO(johnniwinther): This might be dead code.
              getter = abstractField.getter;
              accessKind = CompoundAccessKind.STATIC_GETTER_SETTER;
            }
          } else if (getter.isGetter) {
            accessKind = CompoundAccessKind.STATIC_GETTER_SETTER;
          } else {
            accessKind = CompoundAccessKind.STATIC_METHOD_SETTER;
          }
          return new CompoundAccessSemantics(
              accessKind, getter, element);
        } else {
          return new StaticAccess.staticSetter(element);
        }
      } else {
        return new StaticAccess.staticMethod(element);
      }
    } else if (element.isTopLevel) {
      if (element.isField) {
        if (element.isFinal || element.isConst) {
          // TODO(johnniwinther): Handle const field separately.
          return new StaticAccess.finalTopLevelField(element);
        }
        return new StaticAccess.topLevelField(element);
      } else if (element.isGetter) {
        return new StaticAccess.topLevelGetter(element);
      } else if (element.isSetter) {
        if (getter != null) {
          CompoundAccessKind accessKind;
          if (getter.isErroneous) {
            accessKind = CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER;
          } else if (getter.isAbstractField) {
            AbstractFieldElement abstractField = getter;
            if (abstractField.getter == null) {
              accessKind = CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER;
            } else {
              // TODO(johnniwinther): This might be dead code.
              getter = abstractField.getter;
              accessKind = CompoundAccessKind.TOPLEVEL_GETTER_SETTER;
            }
          } else if (getter.isGetter) {
            accessKind = CompoundAccessKind.TOPLEVEL_GETTER_SETTER;
          } else {
            accessKind = CompoundAccessKind.TOPLEVEL_METHOD_SETTER;
          }
          return new CompoundAccessSemantics(
              accessKind, getter, element);
        } else {
          return new StaticAccess.topLevelSetter(element);
        }
      } else {
        return new StaticAccess.topLevelMethod(element);
      }
    } else {
      return internalError(
          node, "Unhandled resolved property access: $element");
    }
  }

  SendStructure computeSendStructure(Send node) {
    SendStructure sendStructure = elements.getSendStructure(node);
    if (sendStructure != null) {
      return sendStructure;
    }

    if (elements.isAssert(node)) {
      return internalError(node, "Unexpected assert.");
    }

    AssignmentOperator assignmentOperator;
    UnaryOperator unaryOperator;
    BinaryOperator binaryOperator;
    IncDecOperator incDecOperator;

    if (node.isOperator) {
      String operatorText = node.selector.asOperator().source;
      if (operatorText == 'is') {
        return internalError(node, "Unexpected is test.");
      } else if (operatorText == 'as') {
        return internalError(node, "Unexpected as cast.");
      } else if (operatorText == '&&') {
        return internalError(node, "Unexpected logical and.");
      } else if (operatorText == '||') {
        return internalError(node, "Unexpected logical or.");
      } else if (operatorText == '??') {
        return internalError(node, "Unexpected if-null.");
      }
    }

    SendStructureKind kind;

    if (node.asSendSet() != null) {
      SendSet sendSet = node.asSendSet();
      String operatorText = sendSet.assignmentOperator.source;
      if (sendSet.isPrefix || sendSet.isPostfix) {
        kind = sendSet.isPrefix
            ? SendStructureKind.PREFIX
            : SendStructureKind.POSTFIX;
        incDecOperator = IncDecOperator.parse(operatorText);
        if (incDecOperator == null) {
          return internalError(
              node, "No inc/dec operator for '$operatorText'.");
        }
      } else {
        assignmentOperator = AssignmentOperator.parse(operatorText);
        if (assignmentOperator != null) {
          switch (assignmentOperator.kind) {
            case AssignmentOperatorKind.ASSIGN:
              kind = SendStructureKind.SET;
              break;
            default:
              kind = SendStructureKind.COMPOUND;
          }
        } else {
          return internalError(
              node, "No assignment operator for '$operatorText'.");
        }
      }
    } else if (!node.isPropertyAccess) {
      kind = SendStructureKind.INVOKE;
    } else {
      kind = SendStructureKind.GET;
    }

    if (node.isOperator) {
      String operatorText = node.selector.asOperator().source;
      if (node.arguments.isEmpty) {
        return internalError(node, "Unexpected unary $operatorText.");
      } else {
        binaryOperator = BinaryOperator.parse(operatorText);
        if (binaryOperator != null) {
          switch (binaryOperator.kind) {
            case BinaryOperatorKind.EQ:
              kind = SendStructureKind.EQ;
              return internalError(node, "Unexpected binary $kind.");
            case BinaryOperatorKind.NOT_EQ:
              kind = SendStructureKind.NOT_EQ;
              return internalError(node, "Unexpected binary $kind.");
            case BinaryOperatorKind.INDEX:
              if (node.isPrefix) {
                kind = SendStructureKind.INDEX_PREFIX;
              } else if (node.isPostfix) {
                kind = SendStructureKind.INDEX_POSTFIX;
              } else if (node.arguments.tail.isEmpty) {
                // a[b]
                kind = SendStructureKind.INDEX;
                return internalError(node, "Unexpected binary $kind.");
              } else {
                if (kind == SendStructureKind.COMPOUND) {
                  // a[b] += c
                  kind = SendStructureKind.COMPOUND_INDEX_SET;
                } else {
                  // a[b] = c
                  kind = SendStructureKind.INDEX_SET;
                }
              }
              break;
            default:
              kind = SendStructureKind.BINARY;
              return internalError(node, "Unexpected binary $kind.");
          }
        } else {
          return internalError(
              node, "Unexpected invalid binary $operatorText.");
        }
      }
    }
    AccessSemantics semantics = computeAccessSemantics(
        node,
        isSet: kind == SendStructureKind.SET,
        isInvoke: kind == SendStructureKind.INVOKE,
        isCompound: kind == SendStructureKind.COMPOUND ||
                    kind == SendStructureKind.COMPOUND_INDEX_SET ||
                    kind == SendStructureKind.PREFIX ||
                    kind == SendStructureKind.POSTFIX ||
                    kind == SendStructureKind.INDEX_PREFIX ||
                    kind == SendStructureKind.INDEX_POSTFIX);
    if (semantics == null) {
      return internalError(node, 'No semantics for $node');
    }
    Selector selector = elements.getSelector(node);
    switch (kind) {
      case SendStructureKind.GET:
        return new GetStructure(semantics, selector);
      case SendStructureKind.SET:
        return new SetStructure(semantics, selector);
      case SendStructureKind.INVOKE:
        switch (semantics.kind) {
          case AccessKind.STATIC_METHOD:
          case AccessKind.SUPER_METHOD:
          case AccessKind.TOPLEVEL_METHOD:
            // TODO(johnniwinther): Should local function also be handled here?
            if (!selector.callStructure.signatureApplies(semantics.element)) {
              return new IncompatibleInvokeStructure(semantics, selector);
            }
            break;
          default:
            break;
        }
        return new InvokeStructure(semantics, selector);
      case SendStructureKind.UNARY:
        return internalError(node, "Unexpected unary.");
      case SendStructureKind.NOT:
        return internalError(node, "Unexpected not.");
      case SendStructureKind.BINARY:
        return internalError(node, "Unexpected binary.");
      case SendStructureKind.INDEX:
        return internalError(node, "Unexpected index.");
      case SendStructureKind.EQ:
        return internalError(node, "Unexpected equals.");
      case SendStructureKind.NOT_EQ:
        return internalError(node, "Unexpected not equals.");
      case SendStructureKind.COMPOUND:
        Selector getterSelector =
            elements.getGetterSelectorInComplexSendSet(node);
        return new CompoundStructure(
            semantics,
            assignmentOperator,
            getterSelector,
            selector);
      case SendStructureKind.INDEX_SET:
        return new IndexSetStructure(semantics, selector);
      case SendStructureKind.COMPOUND_INDEX_SET:
        Selector getterSelector =
            elements.getGetterSelectorInComplexSendSet(node);
        return new CompoundIndexSetStructure(
            semantics,
            assignmentOperator,
            getterSelector,
            selector);
      case SendStructureKind.INDEX_PREFIX:
        Selector getterSelector =
            elements.getGetterSelectorInComplexSendSet(node);
        return new IndexPrefixStructure(
            semantics,
            incDecOperator,
            getterSelector,
            selector);
      case SendStructureKind.INDEX_POSTFIX:
        Selector getterSelector =
            elements.getGetterSelectorInComplexSendSet(node);
        return new IndexPostfixStructure(
            semantics,
            incDecOperator,
            getterSelector,
            selector);
      case SendStructureKind.PREFIX:
        Selector getterSelector =
            elements.getGetterSelectorInComplexSendSet(node);
        return new PrefixStructure(
            semantics,
            incDecOperator,
            getterSelector,
            selector);
      case SendStructureKind.POSTFIX:
        Selector getterSelector =
            elements.getGetterSelectorInComplexSendSet(node);
        return new PostfixStructure(
            semantics,
            incDecOperator,
            getterSelector,
            selector);
    }
  }

  AccessSemantics computeAccessSemantics(Send node,
                                         {bool isSet: false,
                                          bool isInvoke: false,
                                          bool isCompound: false}) {
    Element element = elements[node];
    Element getter = isCompound ? elements[node.selector] : null;
    if (elements.isTypeLiteral(node)) {
      DartType dartType = elements.getTypeLiteralType(node);
      // TODO(johnniwinther): Handle deferred constants. There are runtime
      // but not compile-time constants and should have their own
      // [DeferredConstantExpression] class.
      ConstantExpression constant = elements.getConstant(
          isInvoke || isSet || isCompound ? node.selector : node);
      switch (dartType.kind) {
        case TypeKind.INTERFACE:
          return new ConstantAccess.classTypeLiteral(constant);
        case TypeKind.TYPEDEF:
          return new ConstantAccess.typedefTypeLiteral(constant);
        case TypeKind.TYPE_VARIABLE:
          return new StaticAccess.typeParameterTypeLiteral(dartType.element);
        case TypeKind.DYNAMIC:
          return new ConstantAccess.dynamicTypeLiteral(constant);
        default:
          return internalError(node, "Unexpected type literal type: $dartType");
      }
    } else if (node.isSuperCall) {
      if (Elements.isUnresolved(element)) {
        if (isCompound) {
          if (Elements.isUnresolved(getter)) {
            // TODO(johnniwinther): Ensure that [getter] is not null. This
            // happens in the case of missing super getter.
            return new StaticAccess.unresolvedSuper(element);
          } else if (getter.isField) {
            assert(invariant(node, getter.isFinal,
                message: "Super field expected to be final."));
            return new StaticAccess.superFinalField(getter);
          } else if (getter.isFunction) {
            if (node.isIndex) {
              return new CompoundAccessSemantics(
                  CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, element);
            } else {
              return new StaticAccess.superMethod(getter);
            }
          } else {
            return new CompoundAccessSemantics(
                CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, element);
          }
        } else {
          return new StaticAccess.unresolvedSuper(element);
        }
      } else if (isCompound && Elements.isUnresolved(getter)) {
        // TODO(johnniwinther): Ensure that [getter] is not null. This happens
        // in the case of missing super getter.
        return new CompoundAccessSemantics(
            CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, element);
      } else if (element.isField) {
        if (getter != null && getter != element) {
          CompoundAccessKind accessKind;
          if (getter.isField) {
            accessKind = CompoundAccessKind.SUPER_FIELD_FIELD;
          } else if (getter.isGetter) {
            accessKind = CompoundAccessKind.SUPER_GETTER_FIELD;
          } else {
            return internalError(node,
               "Unsupported super call: $node : $element/$getter.");
          }
          return new CompoundAccessSemantics(accessKind, getter, element);
        } else if (element.isFinal) {
          return new StaticAccess.superFinalField(element);
        }
        return new StaticAccess.superField(element);
      } else if (element.isGetter) {
        return new StaticAccess.superGetter(element);
      } else if (element.isSetter) {
        if (getter != null) {
          CompoundAccessKind accessKind;
          if (getter.isField) {
            accessKind = CompoundAccessKind.SUPER_FIELD_SETTER;
          } else if (getter.isGetter) {
            accessKind = CompoundAccessKind.SUPER_GETTER_SETTER;
          } else {
            accessKind = CompoundAccessKind.SUPER_METHOD_SETTER;
          }
          return new CompoundAccessSemantics(accessKind, getter, element);
        }
        return new StaticAccess.superSetter(element);
      } else if (isCompound) {
        return new CompoundAccessSemantics(
            CompoundAccessKind.SUPER_GETTER_SETTER, getter, element);
      } else {
        return new StaticAccess.superMethod(element);
      }
    } else if (node.isOperator || node.isConditional) {
      // Conditional sends (e?.x) are treated as dynamic property reads because
      // they are equivalent to do ((a) => a == null ? null : a.x)(e). If `e` is
      // a type `A`, this is equivalent to write `(A).x`.
      // TODO(johnniwinther): maybe add DynamicAccess.conditionalDynamicProperty
      return new DynamicAccess.dynamicProperty(node.receiver);
    } else if (Elements.isClosureSend(node, element)) {
      if (element == null) {
        if (node.selector.isThis()) {
          return new AccessSemantics.thisAccess();
        } else {
          return new AccessSemantics.expression();
        }
      } else if (Elements.isErroneous(element)) {
        return new StaticAccess.unresolved(element);
      } else {
        return handleStaticallyResolvedAccess(
            node, element, getter, isCompound: isCompound);
      }
    } else {
      bool isDynamicAccess(Element e) => e == null || e.isInstanceMember;

      if (isDynamicAccess(element) &&
           (!isCompound || isDynamicAccess(getter))) {
        if (node.receiver == null || node.receiver.isThis()) {
          return new AccessSemantics.thisProperty();
        } else {
          return new DynamicAccess.dynamicProperty(node.receiver);
        }
      } else if (element != null && element.impliesType) {
        // TODO(johnniwinther): Provide an [ErroneousElement].
        // This happens for code like `C.this`.
        return new StaticAccess.unresolved(null);
      } else {
        return handleStaticallyResolvedAccess(
            node, element, getter, isCompound: isCompound);
      }
    }
  }

  ConstructorAccessSemantics computeConstructorAccessSemantics(
        ConstructorElement constructor,
        CallStructure callStructure,
        DartType type,
        {bool mustBeConstant: false}) {
    if (mustBeConstant && !constructor.isConst) {
      return new ConstructorAccessSemantics(
          ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, constructor, type);
    }
    if (constructor.isErroneous) {
      if (constructor is ErroneousElement) {
        ErroneousElement error = constructor;
        if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
          return new ConstructorAccessSemantics(
              ConstructorAccessKind.UNRESOLVED_CONSTRUCTOR, constructor, type);
        }
      }
      return new ConstructorAccessSemantics(
          ConstructorAccessKind.UNRESOLVED_TYPE, constructor, type);
    } else if (constructor.isRedirectingFactory) {
      ConstructorElement effectiveTarget = constructor.effectiveTarget;
      if (effectiveTarget == constructor ||
          effectiveTarget.isErroneous ||
          (mustBeConstant && !effectiveTarget.isConst)) {
        return new ConstructorAccessSemantics(
            ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
            constructor,
            type);
      }
      ConstructorAccessSemantics effectiveTargetSemantics =
          computeConstructorAccessSemantics(
              effectiveTarget,
              callStructure,
              constructor.computeEffectiveTargetType(type));
      if (effectiveTargetSemantics.isErroneous) {
        return new RedirectingFactoryConstructorAccessSemantics(
            ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
            constructor,
            type,
            effectiveTargetSemantics);
      }
      return new RedirectingFactoryConstructorAccessSemantics(
          ConstructorAccessKind.REDIRECTING_FACTORY,
          constructor,
          type,
          effectiveTargetSemantics);
    } else {
      if (!callStructure.signatureApplies(constructor)) {
        return new ConstructorAccessSemantics(
            ConstructorAccessKind.INCOMPATIBLE,
            constructor,
            type);
      } else if (constructor.isFactoryConstructor) {
        return new ConstructorAccessSemantics(
            ConstructorAccessKind.FACTORY, constructor, type);
      } else if (constructor.isRedirectingGenerative) {
        if (constructor.enclosingClass.isAbstract) {
            return new ConstructorAccessSemantics(
                ConstructorAccessKind.ABSTRACT, constructor, type);
        }
        return new ConstructorAccessSemantics(
            ConstructorAccessKind.REDIRECTING_GENERATIVE, constructor, type);
      } else if (constructor.enclosingClass.isAbstract) {
        return new ConstructorAccessSemantics(
            ConstructorAccessKind.ABSTRACT, constructor, type);
      } else {
        return new ConstructorAccessSemantics(
            ConstructorAccessKind.GENERATIVE, constructor, type);
      }
    }
  }

  NewStructure computeNewStructure(NewExpression node) {
    Element element = elements[node.send];
    Selector selector = elements.getSelector(node.send);
    DartType type = elements.getType(node);

    ConstructorAccessSemantics constructorAccessSemantics =
        computeConstructorAccessSemantics(
            element, selector.callStructure, type,
            mustBeConstant: node.isConst);
    if (node.isConst) {
      ConstantExpression constant = elements.getConstant(node);
      if (constructorAccessSemantics.isErroneous ||
          constant == null ||
          constant.kind == ConstantExpressionKind.ERRONEOUS) {
        // This is a non-constant constant constructor invocation, like
        // `const Const(method())`.
        constructorAccessSemantics = new ConstructorAccessSemantics(
            ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, element, type);
      } else {
        ConstantInvokeKind kind;
        switch (constant.kind) {
          case ConstantExpressionKind.CONSTRUCTED:
            kind = ConstantInvokeKind.CONSTRUCTED;
            break;
          case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
            kind = ConstantInvokeKind.BOOL_FROM_ENVIRONMENT;
            break;
          case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
            kind = ConstantInvokeKind.INT_FROM_ENVIRONMENT;
            break;
          case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
            kind = ConstantInvokeKind.STRING_FROM_ENVIRONMENT;
            break;
          default:
            return internalError(
                node, "Unexpected constant kind $kind: ${constant.getText()}");
        }
        return new ConstInvokeStructure(kind, constant);
      }
    }
    return new NewInvokeStructure(constructorAccessSemantics, selector);
  }
}

abstract class DeclStructure<R, A> {
  final FunctionElement element;

  DeclStructure(this.element);

  /// Calls the matching visit method on [visitor] with [node] and [arg].
  R dispatch(SemanticDeclarationVisitor<R, A> visitor,
             FunctionExpression node,
             A arg);
}

enum ConstructorKind {
  GENERATIVE,
  REDIRECTING_GENERATIVE,
  FACTORY,
  REDIRECTING_FACTORY,
}

class ConstructorDeclStructure<R, A> extends DeclStructure<R, A> {
  final ConstructorKind kind;

  ConstructorDeclStructure(this.kind, ConstructorElement constructor)
      : super(constructor);

  R dispatch(SemanticDeclarationVisitor<R, A> visitor,
             FunctionExpression node,
             A arg) {
    switch (kind) {
      case ConstructorKind.GENERATIVE:
        return visitor.visitGenerativeConstructorDeclaration(
            node, element, node.parameters, node.initializers, node.body, arg);
      case ConstructorKind.REDIRECTING_GENERATIVE:
        return visitor.visitRedirectingGenerativeConstructorDeclaration(
            node, element, node.parameters, node.initializers, arg);
      case ConstructorKind.FACTORY:
        return visitor.visitFactoryConstructorDeclaration(
            node, element, node.parameters, node.body, arg);
      default:
        break;
    }
    throw new SpannableAssertionFailure(node,
        "Unhandled constructor declaration kind: ${kind}");
  }
}

class RedirectingFactoryConstructorDeclStructure<R, A>
    extends DeclStructure<R, A> {
  InterfaceType redirectionTargetType;
  ConstructorElement redirectionTarget;

  RedirectingFactoryConstructorDeclStructure(
      ConstructorElement constructor,
      this.redirectionTargetType,
      this.redirectionTarget)
      : super(constructor);

  R dispatch(SemanticDeclarationVisitor<R, A> visitor,
             FunctionExpression node,
             A arg) {
    return visitor.visitRedirectingFactoryConstructorDeclaration(
        node, element, node.parameters,
        redirectionTargetType, redirectionTarget, arg);
  }
}

enum FunctionKind {
  TOP_LEVEL_GETTER,
  TOP_LEVEL_SETTER,
  TOP_LEVEL_FUNCTION,
  STATIC_GETTER,
  STATIC_SETTER,
  STATIC_FUNCTION,
  ABSTRACT_GETTER,
  ABSTRACT_SETTER,
  ABSTRACT_METHOD,
  INSTANCE_GETTER,
  INSTANCE_SETTER,
  INSTANCE_METHOD,
  LOCAL_FUNCTION,
  CLOSURE,
}

class FunctionDeclStructure<R, A>
    extends DeclStructure<R, A> {
  final FunctionKind kind;

  FunctionDeclStructure(this.kind, FunctionElement function)
      : super(function);

  R dispatch(SemanticDeclarationVisitor<R, A> visitor,
             FunctionExpression node,
             A arg) {
    switch (kind) {
      case FunctionKind.TOP_LEVEL_GETTER:
        return visitor.visitTopLevelGetterDeclaration(
            node, element, node.body, arg);
      case FunctionKind.TOP_LEVEL_SETTER:
        return visitor.visitTopLevelSetterDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.TOP_LEVEL_FUNCTION:
        return visitor.visitTopLevelFunctionDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.STATIC_GETTER:
        return visitor.visitStaticGetterDeclaration(
            node, element, node.body, arg);
      case FunctionKind.STATIC_SETTER:
        return visitor.visitStaticSetterDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.STATIC_FUNCTION:
        return visitor.visitStaticFunctionDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.ABSTRACT_GETTER:
        return visitor.visitAbstractGetterDeclaration(
            node, element, arg);
      case FunctionKind.ABSTRACT_SETTER:
        return visitor.visitAbstractSetterDeclaration(
            node, element, node.parameters, arg);
      case FunctionKind.ABSTRACT_METHOD:
        return visitor.visitAbstractMethodDeclaration(
            node, element, node.parameters, arg);
      case FunctionKind.INSTANCE_GETTER:
        return visitor.visitInstanceGetterDeclaration(
            node, element, node.body, arg);
      case FunctionKind.INSTANCE_SETTER:
        return visitor.visitInstanceSetterDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.INSTANCE_METHOD:
        return visitor.visitInstanceMethodDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.LOCAL_FUNCTION:
        return visitor.visitLocalFunctionDeclaration(
            node, element, node.parameters, node.body, arg);
      case FunctionKind.CLOSURE:
        return visitor.visitClosureDeclaration(
            node, element, node.parameters, node.body, arg);
    }
  }
}

abstract class DeclarationResolverMixin {
  TreeElements get elements;

  internalError(Spannable spannable, String message);

  ConstructorKind computeConstructorKind(ConstructorElement constructor) {
    if (constructor.isRedirectingFactory) {
      return ConstructorKind.REDIRECTING_FACTORY;
    } else if (constructor.isFactoryConstructor) {
      return ConstructorKind.FACTORY;
    } else if (constructor.isRedirectingGenerative) {
      return ConstructorKind.REDIRECTING_GENERATIVE;
    } else {
      return ConstructorKind.GENERATIVE;
    }
  }

  DeclStructure computeFunctionStructure(FunctionExpression node) {
    FunctionElement element = elements.getFunctionDefinition(node);
    if (element.isConstructor) {
      ConstructorElement constructor = element;
      ConstructorKind kind = computeConstructorKind(constructor);
      if (kind == ConstructorKind.REDIRECTING_FACTORY) {
        return new RedirectingFactoryConstructorDeclStructure(
            constructor,
            elements.getType(node.body),
            constructor.immediateRedirectionTarget);
      } else {
        return new ConstructorDeclStructure(kind, element);
      }
    } else {
      FunctionKind kind;
      if (element.isLocal) {
        if (element.name.isEmpty) {
          kind = FunctionKind.CLOSURE;
        } else {
          kind = FunctionKind.LOCAL_FUNCTION;
        }
      } else if (element.isInstanceMember) {
        if (element.isGetter) {
          kind = element.isAbstract
              ? FunctionKind.ABSTRACT_GETTER
              : FunctionKind.INSTANCE_GETTER;
        } else if (element.isSetter) {
          kind = element.isAbstract
              ? FunctionKind.ABSTRACT_SETTER
              : FunctionKind.INSTANCE_SETTER;
        } else {
          kind = element.isAbstract
              ? FunctionKind.ABSTRACT_METHOD
              : FunctionKind.INSTANCE_METHOD;
        }
      } else if (element.isStatic) {
        if (element.isGetter) {
          kind = FunctionKind.STATIC_GETTER;
        } else if (element.isSetter) {
          kind = FunctionKind.STATIC_SETTER;
        } else {
          kind = FunctionKind.STATIC_FUNCTION;
        }
      } else if (element.isTopLevel) {
        if (element.isGetter) {
          kind = FunctionKind.TOP_LEVEL_GETTER;
        } else if (element.isSetter) {
          kind = FunctionKind.TOP_LEVEL_SETTER;
        } else {
          kind = FunctionKind.TOP_LEVEL_FUNCTION;
        }
      } else {
        return internalError(node, "Unhandled function expression.");
      }
      return new FunctionDeclStructure(kind, element);
    }
  }

  InitializersStructure computeInitializersStructure(FunctionExpression node) {
    List<InitializerStructure> initializers = <InitializerStructure>[];
    NodeList list = node.initializers;
    bool constructorInvocationSeen = false;
    if (list != null) {
      for (Node initializer in list) {
        InitializerStructure structure =
            computeInitializerStructure(initializer);
        if (structure.isConstructorInvoke) {
          constructorInvocationSeen = true;
        }
        initializers.add(structure);
      }
    }
    if (!constructorInvocationSeen) {
      ConstructorElement currentConstructor = elements[node];
      ClassElement currentClass = currentConstructor.enclosingClass;
      InterfaceType supertype = currentClass.supertype;
      if (supertype != null) {
        ClassElement superclass = supertype.element;
        ConstructorElement superConstructor =
            superclass.lookupDefaultConstructor();
        initializers.add(new ImplicitSuperConstructorInvokeStructure(
            node, superConstructor, supertype));
      }
    }
    return new InitializersStructure(initializers);
  }

  InitializerStructure computeInitializerStructure(Send node) {
    Element element = elements[node];
    if (node.asSendSet() != null) {
      return new FieldInitializerStructure(node, element);
    } else if (Initializers.isConstructorRedirect(node)) {
      return new ThisConstructorInvokeStructure(
          node, element, elements.getSelector(node).callStructure);
    } else if (Initializers.isSuperConstructorCall(node)) {
      return new SuperConstructorInvokeStructure(
          node,
          element,
          elements.analyzedElement.enclosingClass.supertype,
          elements.getSelector(node).callStructure);
    }
    return internalError(node, "Unhandled initializer.");
  }

  List<ParameterStructure> computeParameterStructures(NodeList parameters) {
    List<ParameterStructure> list = <ParameterStructure>[];
    int index = 0;
    for (Node node in parameters) {
      NodeList optionalParameters = node.asNodeList();
      if (optionalParameters != null) {
        bool isNamed = optionalParameters.beginToken.stringValue == '{';
        for (Node node in optionalParameters) {
          list.add(computeParameterStructure(
              node, index++, isRequired: false, isNamed: isNamed));
        }
      } else {
        list.add(computeParameterStructure(node, index++));
      }
    }
    return list;
  }

  ParameterStructure computeParameterStructure(
      VariableDefinitions definitions,
      int index,
      {bool isRequired: true, bool isNamed: false}) {
    Node node = definitions.definitions.nodes.single;
    ParameterElement element = elements[node];
    if (element == null) {
      throw new SpannableAssertionFailure(
          node, "No parameter structure for $node.");
    }
    if (isRequired) {
      return new RequiredParameterStructure(
          definitions, node, element, index);
    } else {
      // TODO(johnniwinther): Should we differentiate between implicit (null)
      // and explicit values? What about optional parameters on redirecting
      // factories?
      if (isNamed) {
        return new NamedParameterStructure(
            definitions, node, element, element.constant);
      } else {
        return new OptionalParameterStructure(
            definitions, node, element, element.constant, index);
      }
    }
  }

  void computeVariableStructures(
      VariableDefinitions definitions,
      void callback(Node node, VariableStructure structure)) {
    for (Node node in definitions.definitions) {
       callback(definitions, computeVariableStructure(node));
    }
  }

  VariableStructure computeVariableStructure(Node node) {
    VariableElement element = elements[node];
    VariableKind kind;
    if (element.isLocal) {
      kind = VariableKind.LOCAL_VARIABLE;
    } else if (element.isInstanceMember) {
      kind = VariableKind.INSTANCE_FIELD;
    } else if (element.isStatic) {
      kind = VariableKind.STATIC_FIELD;
    } else if (element.isTopLevel) {
      kind = VariableKind.TOP_LEVEL_FIELD;
    } else {
      return internalError(node, "Unexpected variable $element.");
    }
    if (element.isConst) {
      ConstantExpression constant = elements.getConstant(element.initializer);
      return new ConstantVariableStructure(kind, node, element, constant);
    } else {
      return new NonConstantVariableStructure(kind, node, element);
    }
  }
}