private static BytecodeExpression generateRequireNotNull(Variable variable) { return invokeStatic(Objects.class, "requireNonNull", Object.class, variable.cast(Object.class), constantString(variable.getName() + " is null")) .cast(variable.getType()); }
invokeStatic(Maps.class, "newHashMapWithExpectedSize", HashMap.class, constantInt(javaTypes.size()))); for (int i = 0; i < javaTypes.size(); i++) { body.append(map.invoke("put", Object.class, constantString(names.get(i)).cast(Object.class), parameterList.get(i).cast(Object.class)));
constantType(binder, transformedKeyType), divide(positionCount, constantInt(2)), constantString(MAP_TRANSFORM_KEY_FUNCTION.getSignature().getName())))); PrestoException.class, getStatic(INVALID_FUNCTION_ARGUMENT.getDeclaringClass(), "INVALID_FUNCTION_ARGUMENT").cast(ErrorCodeSupplier.class), constantString("map key cannot be null"))) .throwObject(); "format", String.class, constantString("Duplicate keys (%s) are not allowed"), newArray(type(Object[].class), ImmutableList.of(transformedKeySqlType.invoke("getObjectValue", Object.class, session, blockBuilder.cast(Block.class), position)))))) .throwObject();
PrestoException.class, getStatic(INVALID_FUNCTION_ARGUMENT.getDeclaringClass(), "INVALID_FUNCTION_ARGUMENT").cast(ErrorCodeSupplier.class), constantString("map key cannot be null"))) .throwObject();
@Test public void testInlineIf() throws Exception { assertBytecodeExpression(inlineIf(constantTrue(), constantString("T"), constantString("F")), true ? "T" : "F", "(true ? \"T\" : \"F\")"); assertBytecodeExpression(inlineIf(constantFalse(), constantString("T"), constantString("F")), false ? "T" : "F", "(false ? \"T\" : \"F\")"); } }
@Test public void testInvokeStaticMethod() throws Exception { assertBytecodeExpression( invokeDynamic(TEST_BOOTSTRAP_METHOD, ImmutableList.of("bar"), "foo", String.class, constantString("baz")), "foo-bar-baz", "[bootstrap(\"bar\")]=>foo(\"baz\")"); }
@Test public void testSetStaticField() throws Exception { assertSetStaticField(setStatic(getClass(), "testField", constantString("testValue"))); assertSetStaticField(setStatic(getClass().getField("testField"), constantString("testValue"))); assertSetStaticField(setStatic(type(getClass()), "testField", constantString("testValue"))); }
@Test public void testInvokeMethod() throws Exception { assertBytecodeExpression(constantString("foo").invoke("length", int.class), "foo".length(), "\"foo\".length()"); assertBytecodeExpression(constantString("foo").invoke("concat", String.class, constantString("bar")), "foo".concat("bar"), "\"foo\".concat(\"bar\")"); assertBytecodeExpression( constantString("foo").invoke("concat", String.class, ImmutableList.of(String.class), constantString("bar")), "foo".concat("bar"), "\"foo\".concat(\"bar\")"); assertBytecodeExpression( constantString("foo").invoke("concat", type(String.class), ImmutableList.of(type(String.class)), constantString("bar")), "foo".concat("bar"), "\"foo\".concat(\"bar\")"); }
private static BytecodeExpression generateRequireNotNull(Variable variable) { return invokeStatic(Objects.class, "requireNonNull", Object.class, variable.cast(Object.class), constantString(variable.getName() + " is null")) .cast(variable.getType()); }
private static BytecodeExpression generateRequireNotNull(Variable variable) { return invokeStatic(Objects.class, "requireNonNull", Object.class, variable.cast(Object.class), constantString(variable.getName() + " is null")) .cast(variable.getType()); }
@Test public void testGetElement() throws Exception { assertBytecodeExpression(constantString("abc").invoke("getBytes", byte[].class).getElement(1), "abc".getBytes()[1], "\"abc\".getBytes()[1]"); assertBytecodeExpression(constantString("abc").invoke("getBytes", byte[].class).getElement(constantInt(1)), "abc".getBytes()[1], "\"abc\".getBytes()[1]"); }
invokeStatic(Maps.class, "newHashMapWithExpectedSize", HashMap.class, constantInt(javaTypes.size()))); for (int i = 0; i < javaTypes.size(); i++) { body.append(map.invoke("put", Object.class, constantString(names.get(i)).cast(Object.class), parameterList.get(i).cast(Object.class)));
@Test public void testNewArrayPrefilled() throws Exception { assertBytecodeExpressionType(newArray(type(boolean[].class), ImmutableList.of(constantTrue(), constantFalse(), constantTrue())), type(boolean[].class)); assertBytecodeExpression( newArray(type(boolean[].class), ImmutableList.of(constantTrue(), constantFalse(), constantTrue())), new boolean[] {true, false, true}, "new boolean[] {true, false, true}"); assertBytecodeExpressionType(newArray(type(int[].class), ImmutableList.of(constantInt(65), constantInt(66), constantInt(99))), type(int[].class)); assertBytecodeExpression( newArray(type(int[].class), ImmutableList.of(constantInt(65), constantInt(66), constantInt(99))), new int[] {65, 66, 99}, "new int[] {65, 66, 99}"); assertBytecodeExpressionType(newArray(type(long[].class), ImmutableList.of(constantLong(1234L), constantLong(12345L), constantLong(9876543210L))), type(long[].class)); assertBytecodeExpression( newArray(type(long[].class), ImmutableList.of(constantLong(1234L), constantLong(12345L), constantLong(9876543210L))), new long[] {1234L, 12345L, 9876543210L}, "new long[] {1234L, 12345L, 9876543210L}"); assertBytecodeExpressionType(newArray(type(String[].class), ImmutableList.of(constantString("grape"), constantNull(String.class), constantString("new"), constantString("array"))), type(String[].class)); assertBytecodeExpression( newArray(type(String[].class), ImmutableList.of(constantString("grape"), constantNull(String.class), constantString("new"), constantString("array"))), new String[] {"grape", null, "new", "array"}, "new String[] {\"grape\", null, \"new\", \"array\"}"); }
@Test public void testSetElement() throws Exception { BytecodeExpression stringArray = constantString("foo bar baz").invoke("split", String[].class, constantString(" ")); assertBytecodeExpressionType(stringArray, type(String[].class)); assertBytecodeExpression(stringArray.length(), 3, "\"foo bar baz\".split(\" \").length"); assertBytecodeExpression(stringArray.getElement(0), "foo", "\"foo bar baz\".split(\" \")[0]"); assertBytecodeExpression(stringArray.getElement(1), "bar", "\"foo bar baz\".split(\" \")[1]"); assertBytecodeExpression(stringArray.getElement(2), "baz", "\"foo bar baz\".split(\" \")[2]"); assertBytecodeExpression(invokeStatic(typeMethodMap.get(boolean[].class), newArray(type(boolean[].class), 5), constantInt(0), constantTrue()), true, classLoader); assertBytecodeExpression(invokeStatic(typeMethodMap.get(int[].class), newArray(type(int[].class), 5), constantInt(0), constantInt(999)), 999, classLoader); assertBytecodeExpression(invokeStatic(typeMethodMap.get(float[].class), newArray(type(float[].class), 5), constantInt(0), constantFloat(0.777f)), 0.777f, classLoader); assertBytecodeExpression(invokeStatic(typeMethodMap.get(double[].class), newArray(type(double[].class), 5), constantInt(0), constantDouble(0.888d)), 0.888d, classLoader); assertBytecodeExpression(invokeStatic(typeMethodMap.get(String[].class), stringArray, constantInt(0), constantString("hello")), "hello", classLoader); }
/** * Define the write method. */ private void defineWriteStructMethod() { Parameter struct = arg("struct", structType); Parameter protocol = arg("protocol", TProtocolWriter.class); MethodDefinition method = classDefinition.declareMethod( a(PUBLIC), "write", null, struct, protocol); BytecodeBlock body = method.getBody(); // ProtocolWriter writer = new ProtocolWriter(protocol); Variable writer = method.getScope().declareVariable(type(ProtocolWriter.class), "writer"); body.append(writer.set(newInstance(ProtocolWriter.class, protocol))); // writer.writeStructBegin("bonk"); body.append(writer.invoke("writeStructBegin", void.class, constantString(metadata.getStructName()))); // write fields for (ThriftFieldMetadata field : metadata.getFields(THRIFT_FIELD)) { body.append(writeField(method, writer, field)); } // writer.writeStructEnd(); body.append(writer.invoke("writeStructEnd", void.class)); body.ret(); }
@SuppressWarnings({"FloatingPointEquality", "ComparisonToNaN", "EqualsNaN", "EqualsWithItself"}) @Test public void testEqual() throws Exception { assertBytecodeExpression(equal(constantInt(7), constantInt(3)), 7 == 3, "(7 == 3)"); assertBytecodeExpression(equal(constantInt(7), constantInt(7)), 7 == 7, "(7 == 7)"); assertBytecodeExpression(equal(constantLong(7L), constantLong(3L)), 7L == 3L, "(7L == 3L)"); assertBytecodeExpression(equal(constantLong(7L), constantLong(7L)), 7L == 7L, "(7L == 7L)"); assertBytecodeExpression(equal(constantFloat(7.7f), constantFloat(3.3f)), 7.7f == 3.3f, "(7.7f == 3.3f)"); assertBytecodeExpression(equal(constantFloat(7.7f), constantFloat(7.7f)), 7.7f == 7.7f, "(7.7f == 7.7f)"); assertBytecodeExpression(equal(constantFloat(Float.NaN), constantFloat(7.7f)), Float.NaN == 7.7f, "(NaNf == 7.7f)"); assertBytecodeExpression(equal(constantFloat(Float.NaN), constantFloat(Float.NaN)), Float.NaN == Float.NaN, "(NaNf == NaNf)"); assertBytecodeExpression(equal(constantDouble(7.7), constantDouble(3.3)), 7.7 == 3.3, "(7.7 == 3.3)"); assertBytecodeExpression(equal(constantDouble(7.7), constantDouble(7.7)), 7.7 == 7.7, "(7.7 == 7.7)"); assertBytecodeExpression(equal(constantDouble(Double.NaN), constantDouble(7.7)), Double.NaN == 7.7, "(NaN == 7.7)"); assertBytecodeExpression(equal(constantDouble(7.7), constantDouble(Double.NaN)), 7.7 == Double.NaN, "(7.7 == NaN)"); assertBytecodeExpression(equal(constantDouble(Double.NaN), constantDouble(Double.NaN)), Double.NaN == Double.NaN, "(NaN == NaN)"); // the byte code is verifying with == but that breaks check style so we use assertBytecodeExpression(equal(constantString("foo"), constantString("bar")), "foo".equals("bar"), "(\"foo\" == \"bar\")"); assertBytecodeExpression(equal(constantString("foo"), constantString("foo")), "foo".equals("foo"), "(\"foo\" == \"foo\")"); }
@SuppressWarnings({"FloatingPointEquality", "ComparisonToNaN", "EqualsNaN", "EqualsWithItself"}) @Test public void testNotEqual() throws Exception { assertBytecodeExpression(notEqual(constantInt(7), constantInt(3)), 7 != 3, "(7 != 3)"); assertBytecodeExpression(notEqual(constantInt(7), constantInt(7)), 7 != 7, "(7 != 7)"); assertBytecodeExpression(notEqual(constantLong(7L), constantLong(3L)), 7L != 3L, "(7L != 3L)"); assertBytecodeExpression(notEqual(constantLong(7L), constantLong(7L)), 7L != 7L, "(7L != 7L)"); assertBytecodeExpression(notEqual(constantFloat(7.7f), constantFloat(3.3f)), 7.7f != 3.3f, "(7.7f != 3.3f)"); assertBytecodeExpression(notEqual(constantFloat(7.7f), constantFloat(7.7f)), 7.7f != 7.7f, "(7.7f != 7.7f)"); assertBytecodeExpression(notEqual(constantFloat(Float.NaN), constantFloat(7.7f)), Float.NaN != 7.7f, "(NaNf != 7.7f)"); assertBytecodeExpression(notEqual(constantFloat(Float.NaN), constantFloat(Float.NaN)), Float.NaN != Float.NaN, "(NaNf != NaNf)"); assertBytecodeExpression(notEqual(constantDouble(7.7), constantDouble(3.3)), 7.7 != 3.3, "(7.7 != 3.3)"); assertBytecodeExpression(notEqual(constantDouble(7.7), constantDouble(7.7)), 7.7 != 7.7, "(7.7 != 7.7)"); assertBytecodeExpression(notEqual(constantDouble(Double.NaN), constantDouble(7.7)), Double.NaN != 7.7, "(NaN != 7.7)"); assertBytecodeExpression(notEqual(constantDouble(7.7), constantDouble(Double.NaN)), 7.7 != Double.NaN, "(7.7 != NaN)"); assertBytecodeExpression(notEqual(constantDouble(Double.NaN), constantDouble(Double.NaN)), Double.NaN != Double.NaN, "(NaN != NaN)"); // the byte code is verifying with != but that breaks check style so we use assertBytecodeExpression(notEqual(constantString("foo"), constantString("bar")), !"foo".equals("bar"), "(\"foo\" != \"bar\")"); assertBytecodeExpression(notEqual(constantString("foo"), constantString("foo")), !"foo".equals("foo"), "(\"foo\" != \"foo\")"); } }
body.append(writer.invoke("writeStructBegin", void.class, constantString(metadata.getStructName())));
@Test public void testNewArray() throws Exception { assertBytecodeExpressionType(newArray(type(boolean[].class), 5), type(boolean[].class)); assertBytecodeExpression(newArray(type(boolean[].class), 5).length(), 5, "new boolean[5].length"); assertBytecodeExpressionType(newArray(type(char[].class), 5), type(char[].class)); assertBytecodeExpression(newArray(type(char[].class), 5).length(), 5, "new char[5].length"); assertBytecodeExpressionType(newArray(type(float[].class), 5), type(float[].class)); assertBytecodeExpression(newArray(type(float[].class), 5).length(), 5, "new float[5].length"); assertBytecodeExpressionType(newArray(type(double[].class), 5), type(double[].class)); assertBytecodeExpression(newArray(type(double[].class), 5).length(), 5, "new double[5].length"); assertBytecodeExpressionType(newArray(type(byte[].class), 5), type(byte[].class)); assertBytecodeExpression(newArray(type(byte[].class), 5).length(), 5, "new byte[5].length"); assertBytecodeExpressionType(newArray(type(short[].class), 5), type(short[].class)); assertBytecodeExpression(newArray(type(short[].class), 5).length(), 5, "new short[5].length"); assertBytecodeExpressionType(newArray(type(int[].class), 5), type(int[].class)); assertBytecodeExpression(newArray(type(int[].class), 5).length(), 5, "new int[5].length"); assertBytecodeExpressionType(newArray(type(long[].class), 5), type(long[].class)); assertBytecodeExpression(newArray(type(long[].class), 5).length(), 5, "new long[5].length"); assertBytecodeExpressionType(constantString("foo bar baz").invoke("split", String[].class, constantString(" ")), type(String[].class)); assertBytecodeExpression(constantString("foo bar baz").invoke("split", String[].class, constantString(" ")).length(), 3, "\"foo bar baz\".split(\" \").length"); }
assertBytecodeExpression(constantDouble(Double.NaN), Double.NaN, "NaN"); assertBytecodeExpression(constantString(""), "", "\"\""); assertBytecodeExpression(constantString("foo"), "foo", "\"foo\"");