| /* |
| * 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 com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.Iterables; |
| import com.google.turbine.binder.bound.AnnotationValue; |
| import com.google.turbine.binder.bound.ClassValue; |
| import com.google.turbine.binder.bound.EnumConstantValue; |
| import com.google.turbine.binder.bound.SourceTypeBoundClass; |
| 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.CompoundScope; |
| import com.google.turbine.binder.lookup.LookupKey; |
| import com.google.turbine.binder.lookup.LookupResult; |
| import com.google.turbine.binder.sym.ClassSymbol; |
| import com.google.turbine.binder.sym.FieldSymbol; |
| import com.google.turbine.diag.TurbineError; |
| import com.google.turbine.diag.TurbineError.ErrorKind; |
| import com.google.turbine.model.Const; |
| import com.google.turbine.model.Const.Value; |
| import com.google.turbine.model.TurbineConstantTypeKind; |
| import com.google.turbine.model.TurbineFlag; |
| 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.PrimTy; |
| import com.google.turbine.tree.Tree.TypeCast; |
| import com.google.turbine.tree.Tree.Unary; |
| 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; |
| |
| /** |
| * 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 ClassSymbol origin; |
| |
| /** The symbol of the enclosing class, for lexical field lookups. */ |
| private final ClassSymbol owner; |
| |
| /** The bound node of the enclosing class. */ |
| private final SourceTypeBoundClass base; |
| |
| /** The constant variable environment. */ |
| private final Env<FieldSymbol, Const.Value> values; |
| |
| /** The class environment. */ |
| private final CompoundEnv<ClassSymbol, TypeBoundClass> env; |
| |
| private final CompoundScope scope; |
| |
| public ConstEvaluator( |
| ClassSymbol origin, |
| ClassSymbol owner, |
| SourceTypeBoundClass base, |
| CompoundScope scope, |
| Env<FieldSymbol, Const.Value> values, |
| CompoundEnv<ClassSymbol, TypeBoundClass> env) { |
| |
| this.origin = origin; |
| this.owner = owner; |
| this.base = base; |
| this.values = values; |
| this.env = env; |
| this.scope = scope; |
| } |
| |
| /** Evaluates the given expression's value. */ |
| public Const eval(Tree t) { |
| switch (t.kind()) { |
| case LITERAL: |
| { |
| Const.Value a = (Const.Value) ((Tree.Literal) t).value(); |
| if (a == null) { |
| return null; |
| } |
| switch (a.constantTypeKind()) { |
| case CHAR: |
| return new Const.CharValue(((com.google.turbine.model.Const.CharValue) a).value()); |
| case INT: |
| return new Const.IntValue(((com.google.turbine.model.Const.IntValue) a).value()); |
| case LONG: |
| return new Const.LongValue(((com.google.turbine.model.Const.LongValue) a).value()); |
| case FLOAT: |
| return new Const.FloatValue(((com.google.turbine.model.Const.FloatValue) a).value()); |
| case DOUBLE: |
| return new Const.DoubleValue( |
| ((com.google.turbine.model.Const.DoubleValue) a).value()); |
| case BOOLEAN: |
| return new Const.BooleanValue( |
| ((com.google.turbine.model.Const.BooleanValue) a).value()); |
| case STRING: |
| return new Const.StringValue( |
| ((com.google.turbine.model.Const.StringValue) a).value()); |
| case SHORT: |
| case BYTE: |
| case NULL: |
| default: |
| 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 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 new AssertionError(t.kind()); |
| } |
| } |
| |
| /** Evaluates a class literal. */ |
| Const evalClassLiteral(ClassLiteral t) { |
| return new ClassValue(evalClassLiteralType(t.type())); |
| } |
| |
| private Type evalClassLiteralType(Tree.Type type) { |
| switch (type.kind()) { |
| case PRIM_TY: |
| return new Type.PrimTy(((PrimTy) type).tykind(), ImmutableList.of()); |
| case VOID_TY: |
| return Type.VOID; |
| case CLASS_TY: |
| return Type.ClassTy.asNonParametricClassTy(resolveClass((ClassTy) type)); |
| case ARR_TY: |
| return new Type.ArrayTy( |
| 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 {@link 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 ClassSymbol resolveClass(ClassTy classTy) { |
| ArrayDeque<String> flat = new ArrayDeque<>(); |
| for (ClassTy curr = classTy; curr != null; curr = curr.base().orNull()) { |
| flat.addFirst(curr.name()); |
| } |
| LookupResult result = scope.lookup(new LookupKey(flat)); |
| if (result == null) { |
| throw error(classTy.position(), ErrorKind.SYMBOL_NOT_FOUND, flat.peekFirst()); |
| } |
| ClassSymbol classSym = (ClassSymbol) result.sym(); |
| for (String bit : result.remaining()) { |
| classSym = Resolve.resolve(env, origin, classSym, bit); |
| if (classSym == null) { |
| throw error(classTy.position(), ErrorKind.SYMBOL_NOT_FOUND, bit); |
| } |
| } |
| return classSym; |
| } |
| |
| /** Evaluates a reference to another constant variable. */ |
| 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) { |
| String 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 = base.memberImports().singleMemberImport(simpleName); |
| if (classSymbol != null) { |
| field = Resolve.resolveField(env, origin, classSymbol, simpleName); |
| if (field != null) { |
| return field; |
| } |
| } |
| Iterator<ClassSymbol> it = base.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; |
| } |
| return null; |
| } |
| |
| private FieldInfo resolveQualifiedField(ConstVarName t) { |
| if (t.name().size() <= 1) { |
| return null; |
| } |
| LookupResult result = scope.lookup(new LookupKey(t.name())); |
| if (result == null) { |
| 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 FieldInfo lexicalField( |
| Env<ClassSymbol, TypeBoundClass> env, ClassSymbol sym, String name) { |
| while (sym != null) { |
| TypeBoundClass info = env.get(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. */ |
| static Const cast(Type ty, Const value) { |
| checkNotNull(value); |
| switch (ty.tyKind()) { |
| case CLASS_TY: |
| case TY_VAR: |
| return value; |
| case PRIM_TY: |
| return coerce((Const.Value) value, ((Type.PrimTy) ty).primkind()); |
| default: |
| throw new AssertionError(ty.tyKind()); |
| } |
| } |
| |
| private static Const.Value coerce(Const.Value value, TurbineConstantTypeKind kind) { |
| switch (kind) { |
| case BOOLEAN: |
| return value.asBoolean(); |
| case STRING: |
| return value.asString(); |
| case LONG: |
| return value.asLong(); |
| case INT: |
| return value.asInteger(); |
| case BYTE: |
| return value.asByte(); |
| case CHAR: |
| return value.asChar(); |
| case SHORT: |
| return value.asShort(); |
| case DOUBLE: |
| return value.asDouble(); |
| case FLOAT: |
| return value.asFloat(); |
| default: |
| throw new AssertionError(kind); |
| } |
| } |
| |
| private Const.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 Const.Value) ? (Const.Value) result : null; |
| } |
| |
| private Const.Value evalConditional(Conditional t) { |
| Const.Value condition = evalValue(t.cond()); |
| if (condition == null) { |
| return null; |
| } |
| return condition.asBoolean().value() ? evalValue(t.iftrue()) : evalValue(t.iffalse()); |
| } |
| |
| private Const.Value evalUnary(Unary t) { |
| Const.Value expr = evalValue(t.expr()); |
| if (expr == null) { |
| return null; |
| } |
| switch (t.op()) { |
| case NOT: |
| return unaryNegate(expr); |
| case BITWISE_COMP: |
| return bitwiseComp(expr); |
| case UNARY_PLUS: |
| return unaryPlus(expr); |
| case NEG: |
| return unaryMinus(expr); |
| default: |
| throw new AssertionError(t.op()); |
| } |
| } |
| |
| private Value unaryNegate(Value expr) { |
| switch (expr.constantTypeKind()) { |
| case BOOLEAN: |
| return new Const.BooleanValue(!expr.asBoolean().value()); |
| default: |
| throw new AssertionError(expr.constantTypeKind()); |
| } |
| } |
| |
| private Value bitwiseComp(Value expr) { |
| expr = promoteUnary(expr); |
| switch (expr.constantTypeKind()) { |
| case INT: |
| return new Const.IntValue(~expr.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(~expr.asLong().value()); |
| default: |
| throw new AssertionError(expr.constantTypeKind()); |
| } |
| } |
| |
| private Value unaryPlus(Value expr) { |
| expr = promoteUnary(expr); |
| switch (expr.constantTypeKind()) { |
| case INT: |
| return new Const.IntValue(+expr.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(+expr.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(+expr.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(+expr.asDouble().value()); |
| default: |
| throw new AssertionError(expr.constantTypeKind()); |
| } |
| } |
| |
| private Value unaryMinus(Value expr) { |
| expr = promoteUnary(expr); |
| switch (expr.constantTypeKind()) { |
| case INT: |
| return new Const.IntValue(-expr.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(-expr.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(-expr.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(-expr.asDouble().value()); |
| default: |
| throw new AssertionError(expr.constantTypeKind()); |
| } |
| } |
| |
| private Const.Value evalCast(TypeCast t) { |
| Const.Value expr = evalValue(t.expr()); |
| if (expr == null) { |
| return null; |
| } |
| switch (t.ty().kind()) { |
| case PRIM_TY: |
| return coerce(expr, ((Tree.PrimTy) t.ty()).tykind()); |
| case CLASS_TY: |
| { |
| ClassTy classTy = (ClassTy) t.ty(); |
| // TODO(cushon): check package? |
| if (!classTy.name().equals("String")) { |
| throw new AssertionError(classTy); |
| } |
| return expr.asString(); |
| } |
| default: |
| throw new AssertionError(t.ty().kind()); |
| } |
| } |
| |
| static Const.Value add(Const.Value a, Const.Value b) { |
| if (a.constantTypeKind() == TurbineConstantTypeKind.STRING |
| || b.constantTypeKind() == TurbineConstantTypeKind.STRING) { |
| return new Const.StringValue(a.asString().value() + b.asString().value()); |
| } |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() + b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() + b.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(a.asFloat().value() + b.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(a.asDouble().value() + b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value subtract(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() - b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() - b.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(a.asFloat().value() - b.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(a.asDouble().value() - b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value mult(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() * b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() * b.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(a.asFloat().value() * b.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(a.asDouble().value() * b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value divide(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() / b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() / b.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(a.asFloat().value() / b.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(a.asDouble().value() / b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value mod(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() % b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() % b.asLong().value()); |
| case FLOAT: |
| return new Const.FloatValue(a.asFloat().value() % b.asFloat().value()); |
| case DOUBLE: |
| return new Const.DoubleValue(a.asDouble().value() % b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static final int INT_SHIFT_MASK = 0b11111; |
| |
| static final int LONG_SHIFT_MASK = 0b111111; |
| |
| static Const.Value shiftLeft(Const.Value a, Const.Value b) { |
| a = promoteUnary(a); |
| b = promoteUnary(b); |
| switch (a.constantTypeKind()) { |
| case INT: |
| return new Const.IntValue( |
| a.asInteger().value() << (b.asInteger().value() & INT_SHIFT_MASK)); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() << (b.asInteger().value() & LONG_SHIFT_MASK)); |
| default: |
| throw new AssertionError(a.constantTypeKind()); |
| } |
| } |
| |
| static Const.Value shiftRight(Const.Value a, Const.Value b) { |
| a = promoteUnary(a); |
| b = promoteUnary(b); |
| switch (a.constantTypeKind()) { |
| case INT: |
| return new Const.IntValue( |
| a.asInteger().value() >> (b.asInteger().value() & INT_SHIFT_MASK)); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() >> (b.asInteger().value() & LONG_SHIFT_MASK)); |
| default: |
| throw new AssertionError(a.constantTypeKind()); |
| } |
| } |
| |
| static Const.Value unsignedShiftRight(Const.Value a, Const.Value b) { |
| a = promoteUnary(a); |
| b = promoteUnary(b); |
| switch (a.constantTypeKind()) { |
| case INT: |
| return new Const.IntValue( |
| a.asInteger().value() >>> (b.asInteger().value() & INT_SHIFT_MASK)); |
| case LONG: |
| return new Const.LongValue( |
| a.asLong().value() >>> (b.asInteger().value() & LONG_SHIFT_MASK)); |
| default: |
| throw new AssertionError(a.constantTypeKind()); |
| } |
| } |
| |
| static Const.Value lessThan(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.BooleanValue(a.asInteger().value() < b.asInteger().value()); |
| case LONG: |
| return new Const.BooleanValue(a.asLong().value() < b.asLong().value()); |
| case FLOAT: |
| return new Const.BooleanValue(a.asFloat().value() < b.asFloat().value()); |
| case DOUBLE: |
| return new Const.BooleanValue(a.asDouble().value() < b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value lessThanEqual(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.BooleanValue(a.asInteger().value() <= b.asInteger().value()); |
| case LONG: |
| return new Const.BooleanValue(a.asLong().value() <= b.asLong().value()); |
| case FLOAT: |
| return new Const.BooleanValue(a.asFloat().value() <= b.asFloat().value()); |
| case DOUBLE: |
| return new Const.BooleanValue(a.asDouble().value() <= b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value greaterThan(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.BooleanValue(a.asInteger().value() > b.asInteger().value()); |
| case LONG: |
| return new Const.BooleanValue(a.asLong().value() > b.asLong().value()); |
| case FLOAT: |
| return new Const.BooleanValue(a.asFloat().value() > b.asFloat().value()); |
| case DOUBLE: |
| return new Const.BooleanValue(a.asDouble().value() > b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value greaterThanEqual(Const.Value a, Const.Value b) { |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.BooleanValue(a.asInteger().value() >= b.asInteger().value()); |
| case LONG: |
| return new Const.BooleanValue(a.asLong().value() >= b.asLong().value()); |
| case FLOAT: |
| return new Const.BooleanValue(a.asFloat().value() >= b.asFloat().value()); |
| case DOUBLE: |
| return new Const.BooleanValue(a.asDouble().value() >= b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value equal(Const.Value a, Const.Value b) { |
| switch (a.constantTypeKind()) { |
| case STRING: |
| return new Const.BooleanValue(a.asString().value().equals(b.asString().value())); |
| case BOOLEAN: |
| return new Const.BooleanValue(a.asBoolean().value() == b.asBoolean().value()); |
| default: |
| break; |
| } |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.BooleanValue(a.asInteger().value() == b.asInteger().value()); |
| case LONG: |
| return new Const.BooleanValue(a.asLong().value() == b.asLong().value()); |
| case FLOAT: |
| return new Const.BooleanValue(a.asFloat().value() == b.asFloat().value()); |
| case DOUBLE: |
| return new Const.BooleanValue(a.asDouble().value() == b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value notEqual(Const.Value a, Const.Value b) { |
| switch (a.constantTypeKind()) { |
| case STRING: |
| return new Const.BooleanValue(!a.asString().value().equals(b.asString().value())); |
| case BOOLEAN: |
| return new Const.BooleanValue(a.asBoolean().value() != b.asBoolean().value()); |
| default: |
| break; |
| } |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.BooleanValue(a.asInteger().value() != b.asInteger().value()); |
| case LONG: |
| return new Const.BooleanValue(a.asLong().value() != b.asLong().value()); |
| case FLOAT: |
| return new Const.BooleanValue(a.asFloat().value() != b.asFloat().value()); |
| case DOUBLE: |
| return new Const.BooleanValue(a.asDouble().value() != b.asDouble().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value bitwiseAnd(Const.Value a, Const.Value b) { |
| switch (a.constantTypeKind()) { |
| case BOOLEAN: |
| return new Const.BooleanValue(a.asBoolean().value() & b.asBoolean().value()); |
| default: |
| break; |
| } |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() & b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() & b.asLong().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value bitwiseOr(Const.Value a, Const.Value b) { |
| switch (a.constantTypeKind()) { |
| case BOOLEAN: |
| return new Const.BooleanValue(a.asBoolean().value() | b.asBoolean().value()); |
| default: |
| break; |
| } |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() | b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() | b.asLong().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| static Const.Value bitwiseXor(Const.Value a, Const.Value b) { |
| switch (a.constantTypeKind()) { |
| case BOOLEAN: |
| return new Const.BooleanValue(a.asBoolean().value() ^ b.asBoolean().value()); |
| default: |
| break; |
| } |
| TurbineConstantTypeKind type = promoteBinary(a, b); |
| a = coerce(a, type); |
| b = coerce(b, type); |
| switch (type) { |
| case INT: |
| return new Const.IntValue(a.asInteger().value() ^ b.asInteger().value()); |
| case LONG: |
| return new Const.LongValue(a.asLong().value() ^ b.asLong().value()); |
| default: |
| throw new AssertionError(type); |
| } |
| } |
| |
| private Const.Value evalBinary(Binary t) { |
| Const.Value lhs = evalValue(t.lhs()); |
| Const.Value rhs = evalValue(t.rhs()); |
| if (lhs == null || rhs == null) { |
| return null; |
| } |
| switch (t.op()) { |
| case PLUS: |
| return add(lhs, rhs); |
| case MINUS: |
| return subtract(lhs, rhs); |
| case MULT: |
| return mult(lhs, rhs); |
| case DIVIDE: |
| return divide(lhs, rhs); |
| case MODULO: |
| return mod(lhs, rhs); |
| case SHIFT_LEFT: |
| return shiftLeft(lhs, rhs); |
| case SHIFT_RIGHT: |
| return shiftRight(lhs, rhs); |
| case UNSIGNED_SHIFT_RIGHT: |
| return unsignedShiftRight(lhs, rhs); |
| case LESS_THAN: |
| return lessThan(lhs, rhs); |
| case GREATER_THAN: |
| return greaterThan(lhs, rhs); |
| case LESS_THAN_EQ: |
| return lessThanEqual(lhs, rhs); |
| case GREATER_THAN_EQ: |
| return greaterThanEqual(lhs, rhs); |
| case EQUAL: |
| return equal(lhs, rhs); |
| case NOT_EQUAL: |
| return notEqual(lhs, rhs); |
| case AND: |
| return new Const.BooleanValue(lhs.asBoolean().value() && rhs.asBoolean().value()); |
| case OR: |
| return new Const.BooleanValue(lhs.asBoolean().value() || rhs.asBoolean().value()); |
| case BITWISE_AND: |
| return bitwiseAnd(lhs, rhs); |
| case BITWISE_XOR: |
| return bitwiseXor(lhs, rhs); |
| case BITWISE_OR: |
| return bitwiseOr(lhs, rhs); |
| default: |
| throw new AssertionError(t.op()); |
| } |
| } |
| |
| private static Const.Value promoteUnary(Const.Value v) { |
| switch (v.constantTypeKind()) { |
| case CHAR: |
| case SHORT: |
| case BYTE: |
| return v.asInteger(); |
| case INT: |
| case LONG: |
| case FLOAT: |
| case DOUBLE: |
| return v; |
| default: |
| throw new AssertionError(v.constantTypeKind()); |
| } |
| } |
| |
| private static TurbineConstantTypeKind promoteBinary(Const.Value a, Const.Value b) { |
| a = promoteUnary(a); |
| b = promoteUnary(b); |
| switch (a.constantTypeKind()) { |
| case INT: |
| switch (b.constantTypeKind()) { |
| case INT: |
| case LONG: |
| case DOUBLE: |
| case FLOAT: |
| return b.constantTypeKind(); |
| default: |
| throw new AssertionError(b.constantTypeKind()); |
| } |
| case LONG: |
| switch (b.constantTypeKind()) { |
| case INT: |
| return TurbineConstantTypeKind.LONG; |
| case LONG: |
| case DOUBLE: |
| case FLOAT: |
| return b.constantTypeKind(); |
| default: |
| throw new AssertionError(b.constantTypeKind()); |
| } |
| case FLOAT: |
| switch (b.constantTypeKind()) { |
| case INT: |
| case LONG: |
| case FLOAT: |
| return TurbineConstantTypeKind.FLOAT; |
| case DOUBLE: |
| return TurbineConstantTypeKind.DOUBLE; |
| default: |
| throw new AssertionError(b.constantTypeKind()); |
| } |
| case DOUBLE: |
| switch (b.constantTypeKind()) { |
| case INT: |
| case LONG: |
| case FLOAT: |
| case DOUBLE: |
| return TurbineConstantTypeKind.DOUBLE; |
| default: |
| throw new AssertionError(b.constantTypeKind()); |
| } |
| default: |
| throw new AssertionError(a.constantTypeKind()); |
| } |
| } |
| |
| ImmutableList<AnnoInfo> evaluateAnnotations(ImmutableList<AnnoInfo> annotations) { |
| ImmutableList.Builder<AnnoInfo> result = ImmutableList.builder(); |
| for (AnnoInfo annotation : annotations) { |
| result.add(evaluateAnnotation(annotation.sym(), annotation.args())); |
| } |
| return result.build(); |
| } |
| |
| /** |
| * Evaluates annotation arguments given the symbol of the annotation declaration and a list of |
| * expression trees. |
| */ |
| AnnoInfo evaluateAnnotation(ClassSymbol sym, ImmutableList<Expression> args) { |
| Map<String, Type> template = new LinkedHashMap<>(); |
| for (MethodInfo method : env.get(sym).methods()) { |
| template.put(method.name(), method.returnType()); |
| } |
| |
| ImmutableMap.Builder<String, Const> values = ImmutableMap.builder(); |
| for (Expression arg : args) { |
| Expression expr; |
| String key; |
| if (arg.kind() == Tree.Kind.ASSIGN) { |
| Tree.Assign assign = (Tree.Assign) arg; |
| key = assign.name(); |
| expr = assign.expr(); |
| } else { |
| // expand the implicit 'value' name; `@Foo(42)` is sugar for `@Foo(value=42)` |
| key = "value"; |
| expr = arg; |
| } |
| Type ty = template.get(key); |
| if (ty == null) { |
| throw error(arg.position(), ErrorKind.CANNOT_RESOLVE, key); |
| } |
| Const value = evalAnnotationValue(expr, ty); |
| if (value == null) { |
| throw error(expr.position(), ErrorKind.EXPRESSION_ERROR); |
| } |
| values.put(key, value); |
| } |
| return new AnnoInfo(sym, args, values.build()); |
| } |
| |
| private AnnotationValue evalAnno(Tree.Anno t) { |
| LookupResult result = scope.lookup(new LookupKey(t.name())); |
| ClassSymbol sym = (ClassSymbol) result.sym(); |
| for (String name : result.remaining()) { |
| sym = Resolve.resolve(env, sym, sym, name); |
| } |
| AnnoInfo annoInfo = evaluateAnnotation(sym, t.args()); |
| return new AnnotationValue(annoInfo.sym(), annoInfo.values()); |
| } |
| |
| private Const.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()); |
| } |
| |
| Const evalAnnotationValue(Tree tree, Type ty) { |
| if (ty == null) { |
| throw error(tree.position(), ErrorKind.EXPRESSION_ERROR); |
| } |
| Const value = eval(tree); |
| switch (ty.tyKind()) { |
| case PRIM_TY: |
| return coerce((Const.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(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(base.source(), position, kind, args); |
| } |
| |
| public Const.Value evalFieldInitializer(Expression expression, Type type) { |
| Const value = eval(expression); |
| if (value == null || value.kind() != Const.Kind.PRIMITIVE) { |
| return null; |
| } |
| return (Const.Value) cast(type, value); |
| } |
| } |
