/*
 * Copyright 2016 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * 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.turbine.binder;

import static com.google.common.base.Preconditions.checkNotNull;
import static java.util.Objects.requireNonNull;

import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.turbine.binder.bound.EnumConstantValue;
import com.google.turbine.binder.bound.TurbineAnnotationValue;
import com.google.turbine.binder.bound.TurbineClassValue;
import com.google.turbine.binder.bound.TypeBoundClass;
import com.google.turbine.binder.bound.TypeBoundClass.FieldInfo;
import com.google.turbine.binder.bound.TypeBoundClass.MethodInfo;
import com.google.turbine.binder.env.CompoundEnv;
import com.google.turbine.binder.env.Env;
import com.google.turbine.binder.lookup.LookupKey;
import com.google.turbine.binder.lookup.LookupResult;
import com.google.turbine.binder.lookup.MemberImportIndex;
import com.google.turbine.binder.lookup.Scope;
import com.google.turbine.binder.sym.ClassSymbol;
import com.google.turbine.binder.sym.FieldSymbol;
import com.google.turbine.binder.sym.Symbol;
import com.google.turbine.diag.SourceFile;
import com.google.turbine.diag.TurbineDiagnostic;
import com.google.turbine.diag.TurbineError;
import com.google.turbine.diag.TurbineError.ErrorKind;
import com.google.turbine.diag.TurbineLog.TurbineLogWithSource;
import com.google.turbine.model.Const;
import com.google.turbine.model.Const.ArrayInitValue;
import com.google.turbine.model.Const.CharValue;
import com.google.turbine.model.Const.ConstCastError;
import com.google.turbine.model.Const.DoubleValue;
import com.google.turbine.model.Const.FloatValue;
import com.google.turbine.model.Const.StringValue;
import com.google.turbine.model.Const.Value;
import com.google.turbine.model.TurbineConstantTypeKind;
import com.google.turbine.model.TurbineFlag;
import com.google.turbine.model.TurbineTyKind;
import com.google.turbine.tree.Tree;
import com.google.turbine.tree.Tree.ArrayInit;
import com.google.turbine.tree.Tree.Binary;
import com.google.turbine.tree.Tree.ClassLiteral;
import com.google.turbine.tree.Tree.ClassTy;
import com.google.turbine.tree.Tree.Conditional;
import com.google.turbine.tree.Tree.ConstVarName;
import com.google.turbine.tree.Tree.Expression;
import com.google.turbine.tree.Tree.Ident;
import com.google.turbine.tree.Tree.Paren;
import com.google.turbine.tree.Tree.PrimTy;
import com.google.turbine.tree.Tree.TypeCast;
import com.google.turbine.tree.Tree.Unary;
import com.google.turbine.tree.TurbineOperatorKind;
import com.google.turbine.type.AnnoInfo;
import com.google.turbine.type.Type;
import java.util.ArrayDeque;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import org.jspecify.nullness.Nullable;

/**
 * Constant expression evaluation.
 *
 * <p>JLS §15.4 requires this class to be strictfp.
 */
public strictfp class ConstEvaluator {

  /** The symbol of the originating class, for visibility checks. */
  private final @Nullable ClassSymbol origin;

  /** The symbol of the enclosing class, for lexical field lookups. */
  private final @Nullable ClassSymbol owner;

  /** Member imports of the enclosing compilation unit. */
  private final MemberImportIndex memberImports;

  /** The current source file. */
  private final SourceFile source;

  /** The constant variable environment. */
  private final Env<FieldSymbol, Value> values;

  /** The class environment. */
  private final CompoundEnv<ClassSymbol, TypeBoundClass> env;

  private final Scope scope;

  private final TurbineLogWithSource log;

  public ConstEvaluator(
      @Nullable ClassSymbol origin,
      @Nullable ClassSymbol owner,
      MemberImportIndex memberImports,
      SourceFile source,
      Scope scope,
      Env<FieldSymbol, Value> values,
      CompoundEnv<ClassSymbol, TypeBoundClass> env,
      TurbineLogWithSource log) {

    this.origin = origin;
    this.owner = owner;
    this.memberImports = memberImports;
    this.source = source;
    this.values = values;
    this.env = env;
    this.scope = scope;
    this.log = log;
  }

  /** Evaluates the given expression's value. */
  public @Nullable Const eval(Tree t) {
    switch (t.kind()) {
      case LITERAL:
        {
          Value a = (Value) ((Tree.Literal) t).value();
          if (a == null) {
            return null;
          }
          switch (a.constantTypeKind()) {
            case CHAR:
            case INT:
            case LONG:
            case FLOAT:
            case DOUBLE:
            case BOOLEAN:
            case STRING:
              return a;
            case SHORT:
            case BYTE:
            case NULL:
          }
          throw new AssertionError(a.constantTypeKind());
        }
      case VOID_TY:
        throw new AssertionError(t.kind());
      case CONST_VAR_NAME:
        return evalConstVar((ConstVarName) t);
      case CLASS_LITERAL:
        return evalClassLiteral((ClassLiteral) t);
      case BINARY:
        return evalBinary((Binary) t);
      case PAREN:
        return eval(((Paren) t).expr());
      case TYPE_CAST:
        return evalCast((TypeCast) t);
      case UNARY:
        return evalUnary((Unary) t);
      case CONDITIONAL:
        return evalConditional((Conditional) t);
      case ARRAY_INIT:
        return evalArrayInit((ArrayInit) t);
      case ANNO_EXPR:
        return evalAnno(((Tree.AnnoExpr) t).value());
      default:
        throw error(t.position(), ErrorKind.EXPRESSION_ERROR);
    }
  }

  /** Evaluates a class literal. */
  Const evalClassLiteral(ClassLiteral t) {
    return new TurbineClassValue(evalClassLiteralType(t.type()));
  }

  private Type evalClassLiteralType(Tree.Type type) {
    switch (type.kind()) {
      case PRIM_TY:
        return Type.PrimTy.create(((PrimTy) type).tykind(), ImmutableList.of());
      case VOID_TY:
        return Type.VOID;
      case CLASS_TY:
        return resolveClass((ClassTy) type);
      case ARR_TY:
        return Type.ArrayTy.create(
            evalClassLiteralType(((Tree.ArrTy) type).elem()), ImmutableList.of());
      default:
        throw new AssertionError(type.kind());
    }
  }

  /**
   * Resolves the {@link ClassSymbol} for the given {@link Tree.ClassTy}, with handling for
   * non-canonical qualified type names.
   *
   * <p>Similar to {@code HierarchyBinder#resolveClass}, except we can't unconditionally consider
   * members of the current class (e.g. when binding constants inside annotations on that class),
   * and when we do want to consider members we can rely on them being in the current scope (it
   * isn't completed during the hierarchy phase).
   */
  private Type resolveClass(ClassTy classTy) {
    ArrayDeque<Ident> flat = new ArrayDeque<>();
    for (ClassTy curr = classTy; curr != null; curr = curr.base().orElse(null)) {
      flat.addFirst(curr.name());
    }
    LookupResult result = scope.lookup(new LookupKey(ImmutableList.copyOf(flat)));
    if (result == null) {
      log.error(classTy.position(), ErrorKind.CANNOT_RESOLVE, flat.getFirst());
      return Type.ErrorTy.create(flat);
    }
    if (result.sym().symKind() != Symbol.Kind.CLASS) {
      throw error(classTy.position(), ErrorKind.UNEXPECTED_TYPE_PARAMETER, flat.getFirst());
    }
    ClassSymbol classSym = (ClassSymbol) result.sym();
    for (Ident bit : result.remaining()) {
      classSym = resolveNext(classTy.position(), classSym, bit);
    }
    return Type.ClassTy.asNonParametricClassTy(classSym);
  }

  private ClassSymbol resolveNext(int position, ClassSymbol sym, Ident bit) {
    ClassSymbol next = Resolve.resolve(env, origin, sym, bit);
    if (next == null) {
      throw error(
          position, ErrorKind.SYMBOL_NOT_FOUND, new ClassSymbol(sym.binaryName() + '$' + bit));
    }
    return next;
  }

  /** Evaluates a reference to another constant variable. */
  @Nullable
  Const evalConstVar(ConstVarName t) {
    FieldInfo field = resolveField(t);
    if (field == null) {
      return null;
    }
    if ((field.access() & TurbineFlag.ACC_ENUM) == TurbineFlag.ACC_ENUM) {
      return new EnumConstantValue(field.sym());
    }
    if (field.value() != null) {
      return field.value();
    }
    return values.get(field.sym());
  }

  FieldInfo resolveField(ConstVarName t) {
    Ident simpleName = t.name().get(0);
    FieldInfo field = lexicalField(env, owner, simpleName);
    if (field != null) {
      return field;
    }
    field = resolveQualifiedField(t);
    if (field != null) {
      return field;
    }
    ClassSymbol classSymbol = memberImports.singleMemberImport(simpleName.value());
    if (classSymbol != null) {
      field = Resolve.resolveField(env, origin, classSymbol, simpleName);
      if (field != null) {
        return field;
      }
    }
    Iterator<ClassSymbol> it = memberImports.onDemandImports();
    while (it.hasNext()) {
      field = Resolve.resolveField(env, origin, it.next(), simpleName);
      if (field == null) {
        continue;
      }
      // resolve handles visibility of inherited members; on-demand imports of private members are
      // a special case
      if ((field.access() & TurbineFlag.ACC_PRIVATE) == TurbineFlag.ACC_PRIVATE) {
        continue;
      }
      return field;
    }
    throw error(
        t.position(),
        ErrorKind.CANNOT_RESOLVE,
        String.format("field %s", Iterables.getLast(t.name())));
  }

  private @Nullable FieldInfo resolveQualifiedField(ConstVarName t) {
    if (t.name().size() <= 1) {
      return null;
    }
    LookupResult result = scope.lookup(new LookupKey(t.name()));
    if (result == null) {
      return null;
    }
    if (result.remaining().isEmpty()) {
      // unexpectedly resolved qualified name to a type
      return null;
    }
    ClassSymbol sym = (ClassSymbol) result.sym();
    for (int i = 0; i < result.remaining().size() - 1; i++) {
      sym = Resolve.resolve(env, sym, sym, result.remaining().get(i));
      if (sym == null) {
        return null;
      }
    }
    return Resolve.resolveField(env, origin, sym, Iterables.getLast(result.remaining()));
  }

  /** Search for constant variables in lexically enclosing scopes. */
  private @Nullable FieldInfo lexicalField(
      Env<ClassSymbol, TypeBoundClass> env, @Nullable ClassSymbol sym, Ident name) {
    while (sym != null) {
      TypeBoundClass info = env.getNonNull(sym);
      FieldInfo field = Resolve.resolveField(env, origin, sym, name);
      if (field != null) {
        return field;
      }
      sym = info.owner();
    }
    return null;
  }

  /** Casts the value to the given type. */
  private Const cast(int position, Type ty, Const value) {
    checkNotNull(value);
    switch (ty.tyKind()) {
      case CLASS_TY:
      case TY_VAR:
        return value;
      case PRIM_TY:
        if (!value.kind().equals(Const.Kind.PRIMITIVE)) {
          throw error(position, ErrorKind.EXPRESSION_ERROR);
        }
        return coerce(position, (Value) value, ((Type.PrimTy) ty).primkind());
      default:
        throw new AssertionError(ty.tyKind());
    }
  }

  /** Casts the constant value to the given type. */
  Value coerce(int position, Value value, TurbineConstantTypeKind kind) {
    switch (kind) {
      case BYTE:
        return asByte(position, value);
      case SHORT:
        return asShort(position, value);
      case INT:
        return asInt(position, value);
      case LONG:
        return asLong(position, value);
      case FLOAT:
        return asFloat(position, value);
      case DOUBLE:
        return asDouble(position, value);
      case CHAR:
        return asChar(position, value);
      case BOOLEAN:
      case STRING:
      case NULL:
        if (!value.constantTypeKind().equals(kind)) {
          throw typeError(position, value, kind);
        }
        return value;
    }
    throw new AssertionError(kind);
  }

  private Const.BooleanValue asBoolean(int position, Value value) {
    if (!value.constantTypeKind().equals(TurbineConstantTypeKind.BOOLEAN)) {
      throw typeError(position, value, TurbineConstantTypeKind.BOOLEAN);
    }
    return (Const.BooleanValue) value;
  }

  private Const.StringValue asString(int position, Value value) {
    if (!value.constantTypeKind().equals(TurbineConstantTypeKind.STRING)) {
      throw typeError(position, value, TurbineConstantTypeKind.STRING);
    }
    return (Const.StringValue) value;
  }

  private Const.StringValue toString(int position, Value value) {
    String result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = String.valueOf(((Const.CharValue) value).value());
        break;
      case SHORT:
        result = String.valueOf(((Const.ShortValue) value).value());
        break;
      case INT:
        result = String.valueOf(((Const.IntValue) value).value());
        break;
      case LONG:
        result = String.valueOf(((Const.LongValue) value).value());
        break;
      case FLOAT:
        result = String.valueOf(((Const.FloatValue) value).value());
        break;
      case DOUBLE:
        result = String.valueOf(((Const.DoubleValue) value).value());
        break;
      case BOOLEAN:
        result = String.valueOf(((Const.BooleanValue) value).value());
        break;
      case BYTE:
        result = String.valueOf(((Const.ByteValue) value).value());
        break;
      case STRING:
        return (StringValue) value;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.STRING);
    }
    return new Const.StringValue(result);
  }

  private Const.CharValue asChar(int position, Value value) {
    char result;
    switch (value.constantTypeKind()) {
      case CHAR:
        return (Const.CharValue) value;
      case BYTE:
        result = (char) ((Const.ByteValue) value).value();
        break;
      case SHORT:
        result = (char) ((Const.ShortValue) value).value();
        break;
      case INT:
        result = (char) ((Const.IntValue) value).value();
        break;
      case LONG:
        result = (char) ((Const.LongValue) value).value();
        break;
      case FLOAT:
        result = (char) ((Const.FloatValue) value).value();
        break;
      case DOUBLE:
        result = (char) ((Const.DoubleValue) value).value();
        break;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.CHAR);
    }
    return new Const.CharValue(result);
  }

  private Const.ByteValue asByte(int position, Value value) {
    byte result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = (byte) ((Const.CharValue) value).value();
        break;
      case BYTE:
        return (Const.ByteValue) value;
      case SHORT:
        result = (byte) ((Const.ShortValue) value).value();
        break;
      case INT:
        result = (byte) ((Const.IntValue) value).value();
        break;
      case LONG:
        result = (byte) ((Const.LongValue) value).value();
        break;
      case FLOAT:
        result = (byte) ((Const.FloatValue) value).value();
        break;
      case DOUBLE:
        result = (byte) ((Const.DoubleValue) value).value();
        break;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.BYTE);
    }
    return new Const.ByteValue(result);
  }

  private Const.ShortValue asShort(int position, Value value) {
    short result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = (short) ((Const.CharValue) value).value();
        break;
      case BYTE:
        result = ((Const.ByteValue) value).value();
        break;
      case SHORT:
        return (Const.ShortValue) value;
      case INT:
        result = (short) ((Const.IntValue) value).value();
        break;
      case LONG:
        result = (short) ((Const.LongValue) value).value();
        break;
      case FLOAT:
        result = (short) ((Const.FloatValue) value).value();
        break;
      case DOUBLE:
        result = (short) ((Const.DoubleValue) value).value();
        break;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.SHORT);
    }
    return new Const.ShortValue(result);
  }

  private Const.IntValue asInt(int position, Value value) {
    int result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = ((CharValue) value).value();
        break;
      case BYTE:
        result = ((Const.ByteValue) value).value();
        break;
      case SHORT:
        result = ((Const.ShortValue) value).value();
        break;
      case INT:
        return (Const.IntValue) value;
      case LONG:
        result = (int) ((Const.LongValue) value).value();
        break;
      case FLOAT:
        result = (int) ((Const.FloatValue) value).value();
        break;
      case DOUBLE:
        result = (int) ((Const.DoubleValue) value).value();
        break;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.INT);
    }
    return new Const.IntValue(result);
  }

  private Const.LongValue asLong(int position, Value value) {
    long result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = ((CharValue) value).value();
        break;
      case BYTE:
        result = ((Const.ByteValue) value).value();
        break;
      case SHORT:
        result = ((Const.ShortValue) value).value();
        break;
      case INT:
        result = ((Const.IntValue) value).value();
        break;
      case LONG:
        return (Const.LongValue) value;
      case FLOAT:
        result = (long) ((Const.FloatValue) value).value();
        break;
      case DOUBLE:
        result = (long) ((Const.DoubleValue) value).value();
        break;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.LONG);
    }
    return new Const.LongValue(result);
  }

  private Const.FloatValue asFloat(int position, Value value) {
    float result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = ((CharValue) value).value();
        break;
      case BYTE:
        result = ((Const.ByteValue) value).value();
        break;
      case SHORT:
        result = ((Const.ShortValue) value).value();
        break;
      case INT:
        result = (float) ((Const.IntValue) value).value();
        break;
      case LONG:
        result = (float) ((Const.LongValue) value).value();
        break;
      case FLOAT:
        return (FloatValue) value;
      case DOUBLE:
        result = (float) ((Const.DoubleValue) value).value();
        break;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.FLOAT);
    }
    return new Const.FloatValue(result);
  }

  private Const.DoubleValue asDouble(int position, Value value) {
    double result;
    switch (value.constantTypeKind()) {
      case CHAR:
        result = ((CharValue) value).value();
        break;
      case BYTE:
        result = ((Const.ByteValue) value).value();
        break;
      case SHORT:
        result = ((Const.ShortValue) value).value();
        break;
      case INT:
        result = ((Const.IntValue) value).value();
        break;
      case LONG:
        result = (double) ((Const.LongValue) value).value();
        break;
      case FLOAT:
        result = ((Const.FloatValue) value).value();
        break;
      case DOUBLE:
        return (DoubleValue) value;
      default:
        throw typeError(position, value, TurbineConstantTypeKind.DOUBLE);
    }
    return new Const.DoubleValue(result);
  }

  private @Nullable Value evalValue(Expression tree) {
    Const result = eval(tree);
    // TODO(cushon): consider distinguishing between constant field and annotation values,
    // and only allowing class literals / enum constants in the latter
    return (result instanceof Value) ? (Value) result : null;
  }

  private @Nullable Value evalConditional(Conditional t) {
    Value condition = evalValue(t.cond());
    if (condition == null) {
      return null;
    }
    return asBoolean(t.position(), condition).value()
        ? evalValue(t.iftrue())
        : evalValue(t.iffalse());
  }

  private @Nullable Value evalUnary(Unary t) {
    Value expr = evalValue(t.expr());
    if (expr == null) {
      return null;
    }
    switch (t.op()) {
      case NOT:
        return unaryNegate(t.position(), expr);
      case BITWISE_COMP:
        return bitwiseComp(t.position(), expr);
      case UNARY_PLUS:
        return unaryPlus(t.position(), expr);
      case NEG:
        return unaryMinus(t.position(), expr);
      default:
        throw new AssertionError(t.op());
    }
  }

  private @Nullable Value unaryNegate(int position, Value expr) {
    switch (expr.constantTypeKind()) {
      case BOOLEAN:
        return new Const.BooleanValue(!asBoolean(position, expr).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, expr.constantTypeKind());
    }
  }

  private @Nullable Value bitwiseComp(int position, Value expr) {
    expr = promoteUnary(position, expr);
    switch (expr.constantTypeKind()) {
      case INT:
        return new Const.IntValue(~asInt(position, expr).value());
      case LONG:
        return new Const.LongValue(~asLong(position, expr).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, expr.constantTypeKind());
    }
  }

  private @Nullable Value unaryPlus(int position, Value expr) {
    expr = promoteUnary(position, expr);
    switch (expr.constantTypeKind()) {
      case INT:
        return new Const.IntValue(+asInt(position, expr).value());
      case LONG:
        return new Const.LongValue(+asLong(position, expr).value());
      case FLOAT:
        return new Const.FloatValue(+asFloat(position, expr).value());
      case DOUBLE:
        return new Const.DoubleValue(+asDouble(position, expr).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, expr.constantTypeKind());
    }
  }

  private @Nullable Value unaryMinus(int position, Value expr) {
    expr = promoteUnary(position, expr);
    switch (expr.constantTypeKind()) {
      case INT:
        return new Const.IntValue(-asInt(position, expr).value());
      case LONG:
        return new Const.LongValue(-asLong(position, expr).value());
      case FLOAT:
        return new Const.FloatValue(-asFloat(position, expr).value());
      case DOUBLE:
        return new Const.DoubleValue(-asDouble(position, expr).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, expr.constantTypeKind());
    }
  }

  private @Nullable Value evalCast(TypeCast t) {
    Value expr = evalValue(t.expr());
    if (expr == null) {
      return null;
    }
    switch (t.ty().kind()) {
      case PRIM_TY:
        return coerce(t.expr().position(), expr, ((Tree.PrimTy) t.ty()).tykind());
      case CLASS_TY:
        {
          ClassTy classTy = (ClassTy) t.ty();
          // TODO(cushon): check package?
          if (!classTy.name().value().equals("String")) {
            // Explicit boxing cases (e.g. `(Boolean) false`) are legal, but not const exprs.
            return null;
          }
          return toString(t.expr().position(), expr);
        }
      default:
        throw new AssertionError(t.ty().kind());
    }
  }

  private @Nullable Value add(int position, Value a, Value b) {
    if (a.constantTypeKind() == TurbineConstantTypeKind.STRING
        || b.constantTypeKind() == TurbineConstantTypeKind.STRING) {
      return new Const.StringValue(toString(position, a).value() + toString(position, b).value());
    }
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() + asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() + asLong(position, b).value());
      case FLOAT:
        return new Const.FloatValue(asFloat(position, a).value() + asFloat(position, b).value());
      case DOUBLE:
        return new Const.DoubleValue(asDouble(position, a).value() + asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value subtract(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() - asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() - asLong(position, b).value());
      case FLOAT:
        return new Const.FloatValue(asFloat(position, a).value() - asFloat(position, b).value());
      case DOUBLE:
        return new Const.DoubleValue(asDouble(position, a).value() - asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value mult(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() * asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() * asLong(position, b).value());
      case FLOAT:
        return new Const.FloatValue(asFloat(position, a).value() * asFloat(position, b).value());
      case DOUBLE:
        return new Const.DoubleValue(asDouble(position, a).value() * asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value divide(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() / asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() / asLong(position, b).value());
      case FLOAT:
        return new Const.FloatValue(asFloat(position, a).value() / asFloat(position, b).value());
      case DOUBLE:
        return new Const.DoubleValue(asDouble(position, a).value() / asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value mod(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() % asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() % asLong(position, b).value());
      case FLOAT:
        return new Const.FloatValue(asFloat(position, a).value() % asFloat(position, b).value());
      case DOUBLE:
        return new Const.DoubleValue(asDouble(position, a).value() % asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private static final int INT_SHIFT_MASK = 0b11111;

  private static final int LONG_SHIFT_MASK = 0b111111;

  private @Nullable Value shiftLeft(int position, Value a, Value b) {
    a = promoteUnary(position, a);
    b = promoteUnary(position, b);
    switch (a.constantTypeKind()) {
      case INT:
        return new Const.IntValue(
            asInt(position, a).value() << (asInt(position, b).value() & INT_SHIFT_MASK));
      case LONG:
        return new Const.LongValue(
            asLong(position, a).value() << (asInt(position, b).value() & LONG_SHIFT_MASK));
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, a.constantTypeKind());
    }
  }

  private @Nullable Value shiftRight(int position, Value a, Value b) {
    a = promoteUnary(position, a);
    b = promoteUnary(position, b);
    switch (a.constantTypeKind()) {
      case INT:
        return new Const.IntValue(
            asInt(position, a).value() >> (asInt(position, b).value() & INT_SHIFT_MASK));
      case LONG:
        return new Const.LongValue(
            asLong(position, a).value() >> (asInt(position, b).value() & LONG_SHIFT_MASK));
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, a.constantTypeKind());
    }
  }

  private @Nullable Value unsignedShiftRight(int position, Value a, Value b) {
    a = promoteUnary(position, a);
    b = promoteUnary(position, b);
    switch (a.constantTypeKind()) {
      case INT:
        return new Const.IntValue(
            asInt(position, a).value() >>> (asInt(position, b).value() & INT_SHIFT_MASK));
      case LONG:
        return new Const.LongValue(
            asLong(position, a).value() >>> (asInt(position, b).value() & LONG_SHIFT_MASK));
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, a.constantTypeKind());
    }
  }

  private @Nullable Value lessThan(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.BooleanValue(asInt(position, a).value() < asInt(position, b).value());
      case LONG:
        return new Const.BooleanValue(asLong(position, a).value() < asLong(position, b).value());
      case FLOAT:
        return new Const.BooleanValue(asFloat(position, a).value() < asFloat(position, b).value());
      case DOUBLE:
        return new Const.BooleanValue(
            asDouble(position, a).value() < asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value lessThanEqual(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.BooleanValue(asInt(position, a).value() <= asInt(position, b).value());
      case LONG:
        return new Const.BooleanValue(asLong(position, a).value() <= asLong(position, b).value());
      case FLOAT:
        return new Const.BooleanValue(asFloat(position, a).value() <= asFloat(position, b).value());
      case DOUBLE:
        return new Const.BooleanValue(
            asDouble(position, a).value() <= asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value greaterThan(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.BooleanValue(asInt(position, a).value() > asInt(position, b).value());
      case LONG:
        return new Const.BooleanValue(asLong(position, a).value() > asLong(position, b).value());
      case FLOAT:
        return new Const.BooleanValue(asFloat(position, a).value() > asFloat(position, b).value());
      case DOUBLE:
        return new Const.BooleanValue(
            asDouble(position, a).value() > asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value greaterThanEqual(int position, Value a, Value b) {
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.BooleanValue(asInt(position, a).value() >= asInt(position, b).value());
      case LONG:
        return new Const.BooleanValue(asLong(position, a).value() >= asLong(position, b).value());
      case FLOAT:
        return new Const.BooleanValue(asFloat(position, a).value() >= asFloat(position, b).value());
      case DOUBLE:
        return new Const.BooleanValue(
            asDouble(position, a).value() >= asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value equal(int position, Value a, Value b) {
    switch (a.constantTypeKind()) {
      case STRING:
        return new Const.BooleanValue(
            asString(position, a).value().equals(asString(position, b).value()));
      case BOOLEAN:
        return new Const.BooleanValue(
            asBoolean(position, a).value() == asBoolean(position, b).value());
      default:
        break;
    }
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.BooleanValue(asInt(position, a).value() == asInt(position, b).value());
      case LONG:
        return new Const.BooleanValue(asLong(position, a).value() == asLong(position, b).value());
      case FLOAT:
        return new Const.BooleanValue(asFloat(position, a).value() == asFloat(position, b).value());
      case DOUBLE:
        return new Const.BooleanValue(
            asDouble(position, a).value() == asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value notEqual(int position, Value a, Value b) {
    switch (a.constantTypeKind()) {
      case STRING:
        return new Const.BooleanValue(
            !asString(position, a).value().equals(asString(position, b).value()));
      case BOOLEAN:
        return new Const.BooleanValue(
            asBoolean(position, a).value() != asBoolean(position, b).value());
      default:
        break;
    }
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.BooleanValue(asInt(position, a).value() != asInt(position, b).value());
      case LONG:
        return new Const.BooleanValue(asLong(position, a).value() != asLong(position, b).value());
      case FLOAT:
        return new Const.BooleanValue(asFloat(position, a).value() != asFloat(position, b).value());
      case DOUBLE:
        return new Const.BooleanValue(
            asDouble(position, a).value() != asDouble(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private Value bitwiseAnd(int position, Value a, Value b) {
    switch (a.constantTypeKind()) {
      case BOOLEAN:
        return new Const.BooleanValue(
            asBoolean(position, a).value() & asBoolean(position, b).value());
      default:
        break;
    }
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() & asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() & asLong(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private Value bitwiseOr(int position, Value a, Value b) {
    switch (a.constantTypeKind()) {
      case BOOLEAN:
        return new Const.BooleanValue(
            asBoolean(position, a).value() | asBoolean(position, b).value());
      default:
        break;
    }
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() | asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() | asLong(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value bitwiseXor(int position, Value a, Value b) {
    switch (a.constantTypeKind()) {
      case BOOLEAN:
        return new Const.BooleanValue(
            asBoolean(position, a).value() ^ asBoolean(position, b).value());
      default:
        break;
    }
    TurbineConstantTypeKind type = promoteBinary(position, a, b);
    a = coerce(position, a, type);
    b = coerce(position, b, type);
    switch (type) {
      case INT:
        return new Const.IntValue(asInt(position, a).value() ^ asInt(position, b).value());
      case LONG:
        return new Const.LongValue(asLong(position, a).value() ^ asLong(position, b).value());
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, type);
    }
  }

  private @Nullable Value evalBinary(Binary t) {
    Value result = null;
    boolean first = true;
    for (Expression child : t.children()) {
      Value value = evalValue(child);
      if (value == null) {
        return null;
      }
      if (first) {
        result = value;
      } else {
        result = evalBinary(child.position(), t.op(), requireNonNull(result), value);
      }
      first = false;
    }
    return result;
  }

  private @Nullable Value evalBinary(int position, TurbineOperatorKind op, Value lhs, Value rhs) {
    switch (op) {
      case PLUS:
        return add(position, lhs, rhs);
      case MINUS:
        return subtract(position, lhs, rhs);
      case MULT:
        return mult(position, lhs, rhs);
      case DIVIDE:
        return divide(position, lhs, rhs);
      case MODULO:
        return mod(position, lhs, rhs);
      case SHIFT_LEFT:
        return shiftLeft(position, lhs, rhs);
      case SHIFT_RIGHT:
        return shiftRight(position, lhs, rhs);
      case UNSIGNED_SHIFT_RIGHT:
        return unsignedShiftRight(position, lhs, rhs);
      case LESS_THAN:
        return lessThan(position, lhs, rhs);
      case GREATER_THAN:
        return greaterThan(position, lhs, rhs);
      case LESS_THAN_EQ:
        return lessThanEqual(position, lhs, rhs);
      case GREATER_THAN_EQ:
        return greaterThanEqual(position, lhs, rhs);
      case EQUAL:
        return equal(position, lhs, rhs);
      case NOT_EQUAL:
        return notEqual(position, lhs, rhs);
      case AND:
        return new Const.BooleanValue(
            asBoolean(position, lhs).value() && asBoolean(position, rhs).value());
      case OR:
        return new Const.BooleanValue(
            asBoolean(position, lhs).value() || asBoolean(position, rhs).value());
      case BITWISE_AND:
        return bitwiseAnd(position, lhs, rhs);
      case BITWISE_XOR:
        return bitwiseXor(position, lhs, rhs);
      case BITWISE_OR:
        return bitwiseOr(position, lhs, rhs);
      default:
        throw new AssertionError(op);
    }
  }

  private Value promoteUnary(int position, Value v) {
    switch (v.constantTypeKind()) {
      case CHAR:
      case SHORT:
      case BYTE:
        return asInt(position, v);
      case INT:
      case LONG:
      case FLOAT:
      case DOUBLE:
        return v;
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, v.constantTypeKind());
    }
  }

  private TurbineConstantTypeKind promoteBinary(int position, Value a, Value b) {
    a = promoteUnary(position, a);
    b = promoteUnary(position, b);
    switch (a.constantTypeKind()) {
      case INT:
        switch (b.constantTypeKind()) {
          case INT:
          case LONG:
          case DOUBLE:
          case FLOAT:
            return b.constantTypeKind();
          default:
            throw error(position, ErrorKind.OPERAND_TYPE, b.constantTypeKind());
        }
      case LONG:
        switch (b.constantTypeKind()) {
          case INT:
            return TurbineConstantTypeKind.LONG;
          case LONG:
          case DOUBLE:
          case FLOAT:
            return b.constantTypeKind();
          default:
            throw error(position, ErrorKind.OPERAND_TYPE, b.constantTypeKind());
        }
      case FLOAT:
        switch (b.constantTypeKind()) {
          case INT:
          case LONG:
          case FLOAT:
            return TurbineConstantTypeKind.FLOAT;
          case DOUBLE:
            return TurbineConstantTypeKind.DOUBLE;
          default:
            throw error(position, ErrorKind.OPERAND_TYPE, b.constantTypeKind());
        }
      case DOUBLE:
        switch (b.constantTypeKind()) {
          case INT:
          case LONG:
          case FLOAT:
          case DOUBLE:
            return TurbineConstantTypeKind.DOUBLE;
          default:
            throw error(position, ErrorKind.OPERAND_TYPE, b.constantTypeKind());
        }
      default:
        throw error(position, ErrorKind.OPERAND_TYPE, a.constantTypeKind());
    }
  }

  ImmutableList<AnnoInfo> evaluateAnnotations(ImmutableList<AnnoInfo> annotations) {
    ImmutableList.Builder<AnnoInfo> result = ImmutableList.builder();
    for (AnnoInfo annotation : annotations) {
      result.add(evaluateAnnotation(annotation));
    }
    return result.build();
  }

  /**
   * Evaluates annotation arguments given the symbol of the annotation declaration and a list of
   * expression trees.
   */
  AnnoInfo evaluateAnnotation(AnnoInfo info) {
    // bail if annotation has not been resolved
    if (info.sym() == null) {
      return info;
    }
    TypeBoundClass annoClass = env.getNonNull(info.sym());
    if (annoClass.kind() != TurbineTyKind.ANNOTATION) {
      // we've already reported an error for non-annotation symbols used as annotations,
      // skip error handling for annotation arguments
      return info;
    }
    Map<String, MethodInfo> template = new LinkedHashMap<>();
    if (annoClass != null) {
      for (MethodInfo method : annoClass.methods()) {
        template.put(method.name(), method);
      }
    }

    Map<String, Const> values = new LinkedHashMap<>();
    for (Expression arg : info.args()) {
      Expression expr;
      String key;
      if (arg.kind() == Tree.Kind.ASSIGN) {
        Tree.Assign assign = (Tree.Assign) arg;
        key = assign.name().value();
        expr = assign.expr();
      } else {
        if (info.args().size() != 1) {
          throw error(arg.position(), ErrorKind.ANNOTATION_VALUE_NAME);
        }
        // expand the implicit 'value' name; `@Foo(42)` is sugar for `@Foo(value=42)`
        key = "value";
        expr = arg;
      }
      MethodInfo methodInfo = template.remove(key);
      if (methodInfo == null) {
        log.error(
            arg.position(),
            ErrorKind.CANNOT_RESOLVE,
            String.format("element %s() in %s", key, info.sym()));
        continue;
      }
      Const value = evalAnnotationValue(expr, methodInfo.returnType());
      if (value == null) {
        log.error(expr.position(), ErrorKind.EXPRESSION_ERROR);
        continue;
      }
      Const existing = values.put(key, value);
      if (existing != null) {
        log.error(arg.position(), ErrorKind.INVALID_ANNOTATION_ARGUMENT);
        continue;
      }
    }
    for (MethodInfo methodInfo : template.values()) {
      if (!methodInfo.hasDefaultValue()) {
        throw error(
            info.tree().position(), ErrorKind.MISSING_ANNOTATION_ARGUMENT, methodInfo.name());
      }
    }
    return info.withValues(ImmutableMap.copyOf(values));
  }

  private @Nullable TurbineAnnotationValue evalAnno(Tree.Anno t) {
    LookupResult result = scope.lookup(new LookupKey(t.name()));
    if (result == null) {
      log.error(
          t.name().get(0).position(), ErrorKind.CANNOT_RESOLVE, Joiner.on(".").join(t.name()));
      return null;
    }
    ClassSymbol sym = (ClassSymbol) result.sym();
    for (Ident name : result.remaining()) {
      sym = Resolve.resolve(env, sym, sym, name);
      if (sym == null) {
        throw error(name.position(), ErrorKind.CANNOT_RESOLVE, name.value());
      }
    }
    if (sym == null) {
      return null;
    }
    if (env.getNonNull(sym).kind() != TurbineTyKind.ANNOTATION) {
      log.error(t.position(), ErrorKind.NOT_AN_ANNOTATION, sym);
    }
    AnnoInfo annoInfo = evaluateAnnotation(new AnnoInfo(source, sym, t, ImmutableMap.of()));
    return new TurbineAnnotationValue(annoInfo);
  }

  private @Nullable ArrayInitValue evalArrayInit(ArrayInit t) {
    ImmutableList.Builder<Const> elements = ImmutableList.builder();
    for (Expression e : t.exprs()) {
      Const arg = eval(e);
      if (arg == null) {
        return null;
      }
      elements.add(arg);
    }
    return new Const.ArrayInitValue(elements.build());
  }

  @Nullable
  Const evalAnnotationValue(Tree tree, Type ty) {
    if (ty == null) {
      throw error(tree.position(), ErrorKind.EXPRESSION_ERROR);
    }
    Const value = eval(tree);
    if (value == null) {
      log.error(tree.position(), ErrorKind.EXPRESSION_ERROR);
      return null;
    }
    switch (ty.tyKind()) {
      case PRIM_TY:
        if (!(value instanceof Value)) {
          throw error(tree.position(), ErrorKind.EXPRESSION_ERROR);
        }
        return coerce(tree.position(), (Value) value, ((Type.PrimTy) ty).primkind());
      case CLASS_TY:
      case TY_VAR:
        return value;
      case ARRAY_TY:
        {
          Type elementType = ((Type.ArrayTy) ty).elementType();
          ImmutableList<Const> elements =
              value.kind() == Const.Kind.ARRAY
                  ? ((Const.ArrayInitValue) value).elements()
                  : ImmutableList.of(value);
          ImmutableList.Builder<Const> coerced = ImmutableList.builder();
          for (Const element : elements) {
            coerced.add(cast(tree.position(), elementType, element));
          }
          return new Const.ArrayInitValue(coerced.build());
        }
      default:
        throw new AssertionError(ty.tyKind());
    }
  }

  private TurbineError error(int position, ErrorKind kind, Object... args) {
    return TurbineError.format(source, position, kind, args);
  }

  private TurbineError typeError(int position, Value value, TurbineConstantTypeKind kind) {
    return error(position, ErrorKind.TYPE_CONVERSION, value, value.constantTypeKind(), kind);
  }

  public @Nullable Value evalFieldInitializer(Expression expression, Type type) {
    try {
      Const value = eval(expression);
      if (value == null || value.kind() != Const.Kind.PRIMITIVE) {
        return null;
      }
      return (Value) cast(expression.position(), type, value);
    } catch (TurbineError error) {
      for (TurbineDiagnostic diagnostic : error.diagnostics()) {
        switch (diagnostic.kind()) {
          case CANNOT_RESOLVE:
            // assume this wasn't a constant
            return null;
          default: // fall out
        }
      }
      throw error;
    } catch (ConstCastError error) {
      return null;
    }
  }
}