diff --git a/cr-examples/triton/src/main/java/oracle/code/triton/SCFOps.java b/cr-examples/triton/src/main/java/oracle/code/triton/SCFOps.java
index 03344931c00..05907159fe5 100644
--- a/cr-examples/triton/src/main/java/oracle/code/triton/SCFOps.java
+++ b/cr-examples/triton/src/main/java/oracle/code/triton/SCFOps.java
@@ -42,22 +42,22 @@ public static final class ForOp extends OpWithDefinition implements Op.Loop {
public static class Builder {
final Body.Builder ancestorBody;
final List<Value> range;
- final FunctionType loopDescriptor;
+ final FunctionType loopType;
- Builder(Body.Builder ancestorBody, List<Value> range, FunctionType loopDescriptor) {
+ Builder(Body.Builder ancestorBody, List<Value> range, FunctionType loopType) {
this.ancestorBody = ancestorBody;
this.range = range;
- this.loopDescriptor = loopDescriptor;
+ this.loopType = loopType;
}
public ForOp body(Consumer<Block.Builder> c) {
- Body.Builder body = Body.Builder.of(ancestorBody, loopDescriptor);
+ Body.Builder body = Body.Builder.of(ancestorBody, loopType);
c.accept(body.entryBlock());
return new ForOp(range, body);
}
public ForOp body(CopyContext cc, Consumer<Block.Builder> c) {
- Body.Builder body = Body.Builder.of(ancestorBody, loopDescriptor, cc);
+ Body.Builder body = Body.Builder.of(ancestorBody, loopType, cc);
c.accept(body.entryBlock());
return new ForOp(range, body);
}
diff --git a/cr-examples/triton/src/main/java/oracle/code/triton/TritonOps.java b/cr-examples/triton/src/main/java/oracle/code/triton/TritonOps.java
index 5fb21ea891f..bc098fc3db9 100644
--- a/cr-examples/triton/src/main/java/oracle/code/triton/TritonOps.java
+++ b/cr-examples/triton/src/main/java/oracle/code/triton/TritonOps.java
@@ -136,16 +136,16 @@ public static final class FuncOp extends TritonOp implements Op.Invokable, Op.Is
public static class Builder {
final Body.Builder ancestorBody;
final String funcName;
- final FunctionType funcDescriptor;
+ final FunctionType funcType;
- Builder(Body.Builder ancestorBody, String funcName, FunctionType funcDescriptor) {
+ Builder(Body.Builder ancestorBody, String funcName, FunctionType funcType) {
this.ancestorBody = ancestorBody;
this.funcName = funcName;
- this.funcDescriptor = funcDescriptor;
+ this.funcType = funcType;
}
public FuncOp body(Consumer<Block.Builder> c) {
- Body.Builder body = Body.Builder.of(ancestorBody, funcDescriptor);
+ Body.Builder body = Body.Builder.of(ancestorBody, funcType);
c.accept(body.entryBlock());
return new FuncOp(funcName, body);
}
@@ -305,17 +305,17 @@ public static class Builder {
final Body.Builder ancestorBody;
final int axis;
final Value v;
- final FunctionType reduceDescriptor;
+ final FunctionType reduceType;
- Builder(Body.Builder ancestorBody, int axis, Value v, FunctionType reduceDescriptor) {
+ Builder(Body.Builder ancestorBody, int axis, Value v, FunctionType reduceType) {
this.ancestorBody = ancestorBody;
this.axis = axis;
this.v = v;
- this.reduceDescriptor = reduceDescriptor;
+ this.reduceType = reduceType;
}
public ReduceOp body(Consumer<Block.Builder> c) {
- Body.Builder body = Body.Builder.of(ancestorBody, reduceDescriptor);
+ Body.Builder body = Body.Builder.of(ancestorBody, reduceType);
c.accept(body.entryBlock());
return new ReduceOp(axis, v, body);
}
@@ -741,8 +741,8 @@ public static ModuleOp module(List<FuncOp> functions) {
return new ModuleOp(List.copyOf(functions));
}
- public static FuncOp.Builder func(String funcName, FunctionType funcDescriptor) {
- return new FuncOp.Builder(null, funcName, funcDescriptor);
+ public static FuncOp.Builder func(String funcName, FunctionType funcType) {
+ return new FuncOp.Builder(null, funcName, funcType);
}
public static FuncOp func(String funcName, Body.Builder body) {
@@ -758,8 +758,8 @@ public static CallOp call(FuncOp func, List<Value> args) {
}
public static ReduceOp.Builder reduce(Body.Builder ancestorBody, int axis, Value tensor,
- FunctionType reduceDescriptor) {
- return new ReduceOp.Builder(ancestorBody, axis, tensor, reduceDescriptor);
+ FunctionType reduceType) {
+ return new ReduceOp.Builder(ancestorBody, axis, tensor, reduceType);
}
public static ReduceOp reduce(int axis, Value tensor, Body.Builder reducerBuilder) {
diff --git a/cr-util/copy-to-compiler.sh b/cr-util/copy-to-compiler.sh
index ffd24bcc3d4..3618cc5c059 100644
--- a/cr-util/copy-to-compiler.sh
+++ b/cr-util/copy-to-compiler.sh
@@ -29,8 +29,6 @@
base=java/lang/reflect/code
packages="
$base \
- $base/descriptor \
- $base/descriptor/impl \
$base/writer \
$base/op \
$base/type \
diff --git a/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeGenerator.java b/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeGenerator.java
index 848806ea3e4..fdaf1756eda 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeGenerator.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeGenerator.java
@@ -46,8 +46,8 @@
import java.lang.invoke.MethodType;
import java.lang.reflect.code.Value;
import java.lang.reflect.code.analysis.Liveness;
-import java.lang.reflect.code.descriptor.FieldDesc;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.FieldRef;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.type.FunctionType;
import java.lang.reflect.code.type.JavaType;
import java.lang.reflect.code.TypeElement;
@@ -91,7 +91,7 @@ public static MethodHandle generate(MethodHandles.Lookup l, CoreOps.FuncOp fop)
try {
FunctionType ft = fop.invokableType();
- MethodType mt = MethodDesc.toNominalDescriptor(ft).resolveConstantDesc(hcl);
+ MethodType mt = MethodRef.toNominalDescriptor(ft).resolveConstantDesc(hcl);
return hcl.findStatic(hcl.lookupClass(), fop.funcName(), mt);
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
@@ -109,7 +109,7 @@ public static byte[] generateClassData(MethodHandles.Lookup lookup, CoreOps.Func
? fop.funcName()
: packageName + "." + fop.funcName();
Liveness liveness = new Liveness(fop);
- MethodTypeDesc mtd = MethodDesc.toNominalDescriptor(fop.invokableType());
+ MethodTypeDesc mtd = MethodRef.toNominalDescriptor(fop.invokableType());
byte[] classBytes = ClassFile.of().build(ClassDesc.of(className), clb ->
clb.withMethodBody(
fop.funcName(),
@@ -600,7 +600,7 @@ private static void generateBody(Body body, CodeBuilder cob, ConversionContext c
cob.invokespecial(
((JavaType) op.resultType()).toNominalDescriptor(),
ConstantDescs.INIT_NAME,
- MethodDesc.toNominalDescriptor(op.constructorType())
+ MethodRef.toNominalDescriptor(op.constructorType())
.changeReturnType(ConstantDescs.CD_void));
}
case 1 -> {
@@ -636,7 +636,7 @@ private static void generateBody(Body body, CodeBuilder cob, ConversionContext c
descKind = DirectMethodHandleDesc.Kind.STATIC;
}
}
- MethodDesc md = op.invokeDescriptor();
+ MethodRef md = op.invokeDescriptor();
cob.invokeInstruction(
switch (descKind) {
case STATIC, INTERFACE_STATIC -> Opcode.INVOKESTATIC;
@@ -648,7 +648,7 @@ private static void generateBody(Body body, CodeBuilder cob, ConversionContext c
},
((JavaType) md.refType()).toNominalDescriptor(),
md.name(),
- MethodDesc.toNominalDescriptor(md.type()),
+ MethodRef.toNominalDescriptor(md.type()),
switch (descKind) {
case INTERFACE_STATIC, INTERFACE_VIRTUAL, INTERFACE_SPECIAL -> true;
default -> false;
@@ -660,7 +660,7 @@ private static void generateBody(Body body, CodeBuilder cob, ConversionContext c
}
case FieldAccessOp.FieldLoadOp op -> {
processOperands(cob, c, op, isLastOpResultOnStack);
- FieldDesc fd = op.fieldDescriptor();
+ FieldRef fd = op.fieldDescriptor();
if (op.operands().isEmpty()) {
cob.getstatic(
((JavaType) fd.refType()).toNominalDescriptor(),
@@ -676,7 +676,7 @@ private static void generateBody(Body body, CodeBuilder cob, ConversionContext c
case FieldAccessOp.FieldStoreOp op -> {
processOperands(cob, c, op, isLastOpResultOnStack);
isLastOpResultOnStack = false;
- FieldDesc fd = op.fieldDescriptor();
+ FieldRef fd = op.fieldDescriptor();
if (op.operands().size() == 1) {
cob.putstatic(
((JavaType) fd.refType()).toNominalDescriptor(),
@@ -1029,7 +1029,7 @@ private static void assignBlockArguments(Op op, Block.Reference s, CodeBuilder c
}
}
- static DirectMethodHandleDesc resolveToMethodHandleDesc(MethodHandles.Lookup l, MethodDesc d) throws ReflectiveOperationException {
+ static DirectMethodHandleDesc resolveToMethodHandleDesc(MethodHandles.Lookup l, MethodRef d) throws ReflectiveOperationException {
MethodHandle mh = d.resolveToHandle(l);
if (mh.describeConstable().isEmpty()) {
diff --git a/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeLift.java b/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeLift.java
index 0995ddd0964..b48f0c3aef8 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeLift.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeLift.java
@@ -42,8 +42,8 @@
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.Op;
import java.lang.reflect.code.Value;
-import java.lang.reflect.code.descriptor.FieldDesc;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.FieldRef;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.op.CoreOps.ExceptionRegionEnter;
import java.lang.reflect.code.type.FunctionType;
import java.lang.reflect.code.type.JavaType;
@@ -72,7 +72,7 @@ public static CoreOps.FuncOp lift(byte[] classdata, String methodName) {
}
public static CoreOps.FuncOp lift(MethodModel methodModel) {
- FunctionType mt = MethodDesc.ofNominalDescriptor(methodModel.methodTypeSymbol());
+ FunctionType mt = MethodRef.ofNominalDescriptor(methodModel.methodTypeSymbol());
return CoreOps.func(
methodModel.methodName().stringValue(),
mt).body(entryBlock -> {
@@ -296,7 +296,7 @@ public static CoreOps.FuncOp lift(MethodModel methodModel) {
}));
}
case FieldInstruction inst -> {
- FieldDesc fd = FieldDesc.field(
+ FieldRef fd = FieldRef.field(
JavaType.ofNominalDescriptor(inst.owner().asSymbol()),
inst.name().stringValue(),
JavaType.ofNominalDescriptor(inst.typeSymbol()));
@@ -325,12 +325,12 @@ public static CoreOps.FuncOp lift(MethodModel methodModel) {
stack.push(currentBlock.op(CoreOps.arrayLoadOp(stack.pop(), index)));
}
case InvokeInstruction inst -> {
- FunctionType mType = MethodDesc.ofNominalDescriptor(inst.typeSymbol());
+ FunctionType mType = MethodRef.ofNominalDescriptor(inst.typeSymbol());
List<Value> operands = new ArrayList<>();
for (var _ : mType.parameterTypes()) {
operands.add(stack.pop());
}
- MethodDesc mDesc = MethodDesc.method(
+ MethodRef mDesc = MethodRef.method(
JavaType.ofNominalDescriptor(inst.owner().asSymbol()),
inst.name().stringValue(),
mType);
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/package-info.java b/src/java.base/share/classes/java/lang/reflect/code/descriptor/package-info.java
deleted file mode 100644
index 7e06a25885c..00000000000
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/package-info.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/**
- * Java descriptors for code models.
- */
-package java.lang.reflect.code.descriptor;
\ No newline at end of file
diff --git a/src/java.base/share/classes/java/lang/reflect/code/interpreter/Interpreter.java b/src/java.base/share/classes/java/lang/reflect/code/interpreter/Interpreter.java
index e03e76dbd12..44f5875c821 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/interpreter/Interpreter.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/interpreter/Interpreter.java
@@ -29,8 +29,8 @@
import java.lang.reflect.Array;
import java.lang.reflect.Proxy;
import java.lang.reflect.code.*;
-import java.lang.reflect.code.descriptor.FieldDesc;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.FieldRef;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.type.FunctionType;
import java.lang.reflect.code.type.JavaType;
@@ -548,11 +548,11 @@ static MethodHandle opHandle(String opName, FunctionType ft) {
}
}
- static MethodHandle methodStaticHandle(MethodHandles.Lookup l, MethodDesc d) {
+ static MethodHandle methodStaticHandle(MethodHandles.Lookup l, MethodRef d) {
return resolveToMethodHandle(l, d);
}
- static MethodHandle methodHandle(MethodHandles.Lookup l, MethodDesc d) {
+ static MethodHandle methodHandle(MethodHandles.Lookup l, MethodRef d) {
return resolveToMethodHandle(l, d);
}
@@ -573,11 +573,11 @@ static MethodHandle constructorHandle(MethodHandles.Lookup l, FunctionType ft) {
}
}
- static VarHandle fieldStaticHandle(MethodHandles.Lookup l, FieldDesc d) {
+ static VarHandle fieldStaticHandle(MethodHandles.Lookup l, FieldRef d) {
return resolveToVarHandle(l, d);
}
- static VarHandle fieldHandle(MethodHandles.Lookup l, FieldDesc d) {
+ static VarHandle fieldHandle(MethodHandles.Lookup l, FieldRef d) {
return resolveToVarHandle(l, d);
}
@@ -591,7 +591,7 @@ static Object cast(MethodHandles.Lookup l, TypeElement d, Object v) {
return c.cast(v);
}
- static MethodHandle resolveToMethodHandle(MethodHandles.Lookup l, MethodDesc d) {
+ static MethodHandle resolveToMethodHandle(MethodHandles.Lookup l, MethodRef d) {
try {
return d.resolveToHandle(l);
} catch (ReflectiveOperationException e) {
@@ -599,7 +599,7 @@ static MethodHandle resolveToMethodHandle(MethodHandles.Lookup l, MethodDesc d)
}
}
- static VarHandle resolveToVarHandle(MethodHandles.Lookup l, FieldDesc d) {
+ static VarHandle resolveToVarHandle(MethodHandles.Lookup l, FieldRef d) {
try {
return d.resolveToHandle(l);
} catch (ReflectiveOperationException e) {
@@ -609,7 +609,7 @@ static VarHandle resolveToVarHandle(MethodHandles.Lookup l, FieldDesc d) {
public static MethodType resolveToMethodType(MethodHandles.Lookup l, FunctionType ft) {
try {
- return MethodDesc.toNominalDescriptor(ft).resolveConstantDesc(l);
+ return MethodRef.toNominalDescriptor(ft).resolveConstantDesc(l);
} catch (ReflectiveOperationException e) {
throw interpreterException(e);
}
diff --git a/src/java.base/share/classes/java/lang/reflect/code/op/CoreOps.java b/src/java.base/share/classes/java/lang/reflect/code/op/CoreOps.java
index c3bb008742b..fd8b33c42c9 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/op/CoreOps.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/op/CoreOps.java
@@ -26,8 +26,8 @@
package java.lang.reflect.code.op;
import java.lang.reflect.code.*;
-import java.lang.reflect.code.descriptor.FieldDesc;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.FieldRef;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.type.*;
import java.lang.reflect.code.type.impl.JavaTypeImpl;
import java.util.*;
@@ -330,7 +330,7 @@ public TypeElement resultType() {
public static final class QuotedOp extends OpWithDefinition implements Op.Nested, Op.Lowerable, Op.Pure {
public static final String NAME = "quoted";
- // Type description must be the same in the java.base and jdk.compiler module
+ // Type name must be the same in the java.base and jdk.compiler module
static final String Quoted_CLASS_NAME = PACKAGE_NAME +
"." + Quoted.class.getSimpleName();
public static final JavaType QUOTED_TYPE = new JavaTypeImpl(Quoted_CLASS_NAME);
@@ -1190,21 +1190,21 @@ public static final class InvokeOp extends OpWithDefinition implements Reflectiv
public static final String NAME = "invoke";
public static final String ATTRIBUTE_INVOKE_DESCRIPTOR = NAME + ".descriptor";
- final MethodDesc invokeDescriptor;
+ final MethodRef invokeDescriptor;
final TypeElement resultType;
public static InvokeOp create(OpDefinition def) {
- MethodDesc invokeDescriptor = def.extractAttributeValue(ATTRIBUTE_INVOKE_DESCRIPTOR,
+ MethodRef invokeDescriptor = def.extractAttributeValue(ATTRIBUTE_INVOKE_DESCRIPTOR,
true, v -> switch(v) {
- case String s -> MethodDesc.ofString(s);
- case MethodDesc md -> md;
+ case String s -> MethodRef.ofString(s);
+ case MethodRef md -> md;
default -> throw new UnsupportedOperationException("Unsupported invoke descriptor value:" + v);
});
return new InvokeOp(def, invokeDescriptor);
}
- InvokeOp(OpDefinition def, MethodDesc invokeDescriptor) {
+ InvokeOp(OpDefinition def, MethodRef invokeDescriptor) {
super(def);
this.invokeDescriptor = invokeDescriptor;
@@ -1223,11 +1223,11 @@ public InvokeOp transform(CopyContext cc, OpTransformer ot) {
return new InvokeOp(this, cc);
}
- InvokeOp(MethodDesc invokeDescriptor, List<Value> args) {
+ InvokeOp(MethodRef invokeDescriptor, List<Value> args) {
this(invokeDescriptor.type().returnType(), invokeDescriptor, args);
}
- InvokeOp(TypeElement resultType, MethodDesc invokeDescriptor, List<Value> args) {
+ InvokeOp(TypeElement resultType, MethodRef invokeDescriptor, List<Value> args) {
super(NAME, args);
this.invokeDescriptor = invokeDescriptor;
@@ -1241,7 +1241,7 @@ public Map<String, Object> attributes() {
return Collections.unmodifiableMap(m);
}
- public MethodDesc invokeDescriptor() {
+ public MethodRef invokeDescriptor() {
return invokeDescriptor;
}
@@ -1385,9 +1385,9 @@ public sealed interface AccessOp {
public abstract static sealed class FieldAccessOp extends OpWithDefinition implements AccessOp, ReflectiveOp {
public static final String ATTRIBUTE_FIELD_DESCRIPTOR = "field.descriptor";
- final FieldDesc fieldDescriptor;
+ final FieldRef fieldDescriptor;
- FieldAccessOp(OpDefinition def, FieldDesc fieldDescriptor) {
+ FieldAccessOp(OpDefinition def, FieldRef fieldDescriptor) {
super(def);
this.fieldDescriptor = fieldDescriptor;
@@ -1400,7 +1400,7 @@ public abstract static sealed class FieldAccessOp extends OpWithDefinition imple
}
FieldAccessOp(String name, List<Value> operands,
- FieldDesc fieldDescriptor) {
+ FieldRef fieldDescriptor) {
super(name, operands);
this.fieldDescriptor = fieldDescriptor;
@@ -1413,7 +1413,7 @@ public Map<String, Object> attributes() {
return Collections.unmodifiableMap(m);
}
- public final FieldDesc fieldDescriptor() {
+ public final FieldRef fieldDescriptor() {
return fieldDescriptor;
}
@@ -1432,16 +1432,16 @@ public static FieldLoadOp create(OpDefinition def) {
throw new IllegalArgumentException("Operation must accept zero or one operand");
}
- FieldDesc fieldDescriptor = def.extractAttributeValue(ATTRIBUTE_FIELD_DESCRIPTOR,true,
+ FieldRef fieldDescriptor = def.extractAttributeValue(ATTRIBUTE_FIELD_DESCRIPTOR,true,
v -> switch(v) {
- case String s -> FieldDesc.ofString(s);
- case FieldDesc fd -> fd;
+ case String s -> FieldRef.ofString(s);
+ case FieldRef fd -> fd;
default -> throw new UnsupportedOperationException("Unsupported field descriptor value:" + v);
});
return new FieldLoadOp(def, fieldDescriptor);
}
- FieldLoadOp(OpDefinition opdef, FieldDesc fieldDescriptor) {
+ FieldLoadOp(OpDefinition opdef, FieldRef fieldDescriptor) {
super(opdef, fieldDescriptor);
resultType = opdef.resultType();
@@ -1459,14 +1459,14 @@ public FieldLoadOp transform(CopyContext cc, OpTransformer ot) {
}
// instance
- FieldLoadOp(TypeElement resultType, FieldDesc descriptor, Value receiver) {
+ FieldLoadOp(TypeElement resultType, FieldRef descriptor, Value receiver) {
super(NAME, List.of(receiver), descriptor);
this.resultType = resultType;
}
// static
- FieldLoadOp(TypeElement resultType, FieldDesc descriptor) {
+ FieldLoadOp(TypeElement resultType, FieldRef descriptor) {
super(NAME, List.of(), descriptor);
this.resultType = resultType;
@@ -1491,16 +1491,16 @@ public static FieldStoreOp create(OpDefinition def) {
throw new IllegalArgumentException("Operation must accept one or two operands");
}
- FieldDesc fieldDescriptor = def.extractAttributeValue(ATTRIBUTE_FIELD_DESCRIPTOR,true,
+ FieldRef fieldDescriptor = def.extractAttributeValue(ATTRIBUTE_FIELD_DESCRIPTOR,true,
v -> switch(v) {
- case String s -> FieldDesc.ofString(s);
- case FieldDesc fd -> fd;
+ case String s -> FieldRef.ofString(s);
+ case FieldRef fd -> fd;
default -> throw new UnsupportedOperationException("Unsupported field descriptor value:" + v);
});
return new FieldStoreOp(def, fieldDescriptor);
}
- FieldStoreOp(OpDefinition opdef, FieldDesc fieldDescriptor) {
+ FieldStoreOp(OpDefinition opdef, FieldRef fieldDescriptor) {
super(opdef, fieldDescriptor);
}
@@ -1514,13 +1514,13 @@ public FieldStoreOp transform(CopyContext cc, OpTransformer ot) {
}
// instance
- FieldStoreOp(FieldDesc descriptor, Value receiver, Value v) {
+ FieldStoreOp(FieldRef descriptor, Value receiver, Value v) {
super(NAME,
List.of(receiver, v), descriptor);
}
// static
- FieldStoreOp(FieldDesc descriptor, Value v) {
+ FieldStoreOp(FieldRef descriptor, Value v) {
super(NAME,
List.of(v), descriptor);
}
@@ -2928,29 +2928,29 @@ public static FuncOp func(String funcName, Body.Builder body) {
/**
* Creates a function call operation
* @param funcName the name of the function operation
- * @param funcDescriptor the function descriptor
+ * @param funcType the function type
* @param args the function arguments
* @return the function call operation
*/
- public static FuncCallOp funcCall(String funcName, FunctionType funcDescriptor, Value... args) {
- return funcCall(funcName, funcDescriptor, List.of(args));
+ public static FuncCallOp funcCall(String funcName, FunctionType funcType, Value... args) {
+ return funcCall(funcName, funcType, List.of(args));
}
/**
* Creates a function call operation
* @param funcName the name of the function operation
- * @param funcDescriptor the function descriptor
+ * @param funcType the function type
* @param args the function arguments
* @return the function call operation
*/
- public static FuncCallOp funcCall(String funcName, FunctionType funcDescriptor, List<Value> args) {
- return new FuncCallOp(funcName, funcDescriptor.returnType(), args);
+ public static FuncCallOp funcCall(String funcName, FunctionType funcType, List<Value> args) {
+ return new FuncCallOp(funcName, funcType.returnType(), args);
}
/**
* Creates a function call operation
* @param func the target function
- * @param args the function argments
+ * @param args the function arguments
* @return the function call operation
*/
public static FuncCallOp funcCall(FuncOp func, Value... args) {
@@ -3202,7 +3202,7 @@ public static ConstantOp constant(TypeElement type, Object value) {
* @param args the invoke parameters
* @return the invoke operation
*/
- public static InvokeOp invoke(MethodDesc invokeDescriptor, Value... args) {
+ public static InvokeOp invoke(MethodRef invokeDescriptor, Value... args) {
return new InvokeOp(invokeDescriptor, List.of(args));
}
@@ -3213,7 +3213,7 @@ public static InvokeOp invoke(MethodDesc invokeDescriptor, Value... args) {
* @param args the invoke parameters
* @return the invoke operation
*/
- public static InvokeOp invoke(MethodDesc invokeDescriptor, List<Value> args) {
+ public static InvokeOp invoke(MethodRef invokeDescriptor, List<Value> args) {
return new InvokeOp(invokeDescriptor, args);
}
@@ -3225,7 +3225,7 @@ public static InvokeOp invoke(MethodDesc invokeDescriptor, List<Value> args) {
* @param args the invoke parameters
* @return the invoke operation
*/
- public static InvokeOp invoke(TypeElement returnType, MethodDesc invokeDescriptor, Value... args) {
+ public static InvokeOp invoke(TypeElement returnType, MethodRef invokeDescriptor, Value... args) {
return new InvokeOp(returnType, invokeDescriptor, List.of(args));
}
@@ -3237,7 +3237,7 @@ public static InvokeOp invoke(TypeElement returnType, MethodDesc invokeDescripto
* @param args the invoke parameters
* @return the invoke operation
*/
- public static InvokeOp invoke(TypeElement returnType, MethodDesc invokeDescriptor, List<Value> args) {
+ public static InvokeOp invoke(TypeElement returnType, MethodRef invokeDescriptor, List<Value> args) {
return new InvokeOp(returnType, invokeDescriptor, args);
}
@@ -3320,7 +3320,7 @@ public static NewOp newArray(TypeElement arrayType, Value length) {
* @param receiver the receiver value
* @return the field load operation
*/
- public static FieldAccessOp.FieldLoadOp fieldLoad(FieldDesc descriptor, Value receiver) {
+ public static FieldAccessOp.FieldLoadOp fieldLoad(FieldRef descriptor, Value receiver) {
return new FieldAccessOp.FieldLoadOp(descriptor.type(), descriptor, receiver);
}
@@ -3332,7 +3332,7 @@ public static FieldAccessOp.FieldLoadOp fieldLoad(FieldDesc descriptor, Value re
* @param receiver the receiver value
* @return the field load operation
*/
- public static FieldAccessOp.FieldLoadOp fieldLoad(TypeElement resultType, FieldDesc descriptor, Value receiver) {
+ public static FieldAccessOp.FieldLoadOp fieldLoad(TypeElement resultType, FieldRef descriptor, Value receiver) {
return new FieldAccessOp.FieldLoadOp(resultType, descriptor, receiver);
}
@@ -3342,7 +3342,7 @@ public static FieldAccessOp.FieldLoadOp fieldLoad(TypeElement resultType, FieldD
* @param descriptor the field descriptor
* @return the field load operation
*/
- public static FieldAccessOp.FieldLoadOp fieldLoad(FieldDesc descriptor) {
+ public static FieldAccessOp.FieldLoadOp fieldLoad(FieldRef descriptor) {
return new FieldAccessOp.FieldLoadOp(descriptor.type(), descriptor);
}
@@ -3353,7 +3353,7 @@ public static FieldAccessOp.FieldLoadOp fieldLoad(FieldDesc descriptor) {
* @param descriptor the field descriptor
* @return the field load operation
*/
- public static FieldAccessOp.FieldLoadOp fieldLoad(TypeElement resultType, FieldDesc descriptor) {
+ public static FieldAccessOp.FieldLoadOp fieldLoad(TypeElement resultType, FieldRef descriptor) {
return new FieldAccessOp.FieldLoadOp(resultType, descriptor);
}
@@ -3365,7 +3365,7 @@ public static FieldAccessOp.FieldLoadOp fieldLoad(TypeElement resultType, FieldD
* @param v the value to store
* @return the field store operation
*/
- public static FieldAccessOp.FieldStoreOp fieldStore(FieldDesc descriptor, Value receiver, Value v) {
+ public static FieldAccessOp.FieldStoreOp fieldStore(FieldRef descriptor, Value receiver, Value v) {
return new FieldAccessOp.FieldStoreOp(descriptor, receiver, v);
}
@@ -3376,7 +3376,7 @@ public static FieldAccessOp.FieldStoreOp fieldStore(FieldDesc descriptor, Value
* @param v the value to store
* @return the field store operation
*/
- public static FieldAccessOp.FieldStoreOp fieldStore(FieldDesc descriptor, Value v) {
+ public static FieldAccessOp.FieldStoreOp fieldStore(FieldRef descriptor, Value v) {
return new FieldAccessOp.FieldStoreOp(descriptor, v);
}
@@ -3416,7 +3416,7 @@ public static ArrayAccessOp.ArrayStoreOp arrayStoreOp(Value array, Value index,
/**
* Creates an instanceof operation.
*
- * @param t the type descriptor of the type to test against
+ * @param t the type to test against
* @param v the value to test
* @return the instanceof operation
*/
@@ -3439,7 +3439,7 @@ public static CastOp cast(TypeElement resultType, Value v) {
* Creates a cast operation.
*
* @param resultType the result type of the operation
- * @param t the type descriptor of the type to cast to
+ * @param t the type to cast to
* @param v the value to cast
* @return the cast operation
*/
diff --git a/src/java.base/share/classes/java/lang/reflect/code/op/ExtendedOps.java b/src/java.base/share/classes/java/lang/reflect/code/op/ExtendedOps.java
index ca39d113f5a..128a35ac3b9 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/op/ExtendedOps.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/op/ExtendedOps.java
@@ -26,8 +26,8 @@
package java.lang.reflect.code.op;
import java.lang.reflect.code.*;
-import java.lang.reflect.code.descriptor.MethodDesc;
-import java.lang.reflect.code.descriptor.RecordTypeDesc;
+import java.lang.reflect.code.type.MethodRef;
+import java.lang.reflect.code.type.RecordTypeRef;
import java.lang.reflect.code.type.FunctionType;
import java.lang.reflect.code.type.JavaType;
import java.lang.reflect.code.type.TupleType;
@@ -1188,9 +1188,9 @@ public Body loopBody() {
return body;
}
- static final MethodDesc ITERABLE_ITERATOR = MethodDesc.method(Iterable.class, "iterator", Iterator.class);
- static final MethodDesc ITERATOR_HAS_NEXT = MethodDesc.method(Iterator.class, "hasNext", boolean.class);
- static final MethodDesc ITERATOR_NEXT = MethodDesc.method(Iterator.class, "next", Object.class);
+ static final MethodRef ITERABLE_ITERATOR = MethodRef.method(Iterable.class, "iterator", Iterator.class);
+ static final MethodRef ITERATOR_HAS_NEXT = MethodRef.method(Iterator.class, "hasNext", boolean.class);
+ static final MethodRef ITERATOR_NEXT = MethodRef.method(Iterator.class, "next", Object.class);
@Override
public Block.Builder lower(Block.Builder b, OpTransformer opT) {
@@ -2508,20 +2508,20 @@ public static final class RecordPatternOp extends PatternOp {
public static final String ATTRIBUTE_RECORD_DESCRIPTOR = NAME + ".descriptor";
- final RecordTypeDesc recordDescriptor;
+ final RecordTypeRef recordDescriptor;
public static RecordPatternOp create(OpDefinition def) {
- RecordTypeDesc recordDescriptor = def.extractAttributeValue(ATTRIBUTE_RECORD_DESCRIPTOR,true,
+ RecordTypeRef recordDescriptor = def.extractAttributeValue(ATTRIBUTE_RECORD_DESCRIPTOR,true,
v -> switch (v) {
- case String s -> RecordTypeDesc.ofString(s);
- case RecordTypeDesc rtd -> rtd;
+ case String s -> RecordTypeRef.ofString(s);
+ case RecordTypeRef rtd -> rtd;
default -> throw new UnsupportedOperationException("Unsupported record type descriptor value:" + v);
});
return new RecordPatternOp(def, recordDescriptor);
}
- RecordPatternOp(OpDefinition def, RecordTypeDesc recordDescriptor) {
+ RecordPatternOp(OpDefinition def, RecordTypeRef recordDescriptor) {
super(def);
this.recordDescriptor = recordDescriptor;
@@ -2538,7 +2538,7 @@ public RecordPatternOp transform(CopyContext cc, OpTransformer ot) {
return new RecordPatternOp(this, cc);
}
- RecordPatternOp(RecordTypeDesc recordDescriptor, List<Value> nestedPatterns) {
+ RecordPatternOp(RecordTypeRef recordDescriptor, List<Value> nestedPatterns) {
// The type of each value is a subtype of Pattern
// The number of values corresponds to the number of components of the record
super(NAME, List.copyOf(nestedPatterns));
@@ -2553,7 +2553,7 @@ public Map<String, Object> attributes() {
return Collections.unmodifiableMap(m);
}
- public RecordTypeDesc recordDescriptor() {
+ public RecordTypeRef recordDescriptor() {
return recordDescriptor;
}
@@ -3130,7 +3130,7 @@ public static PatternOps.BindingPatternOp bindingPattern(TypeElement type, Strin
* @param nestedPatterns the nested pattern values
* @return the record pattern operation
*/
- public static PatternOps.RecordPatternOp recordPattern(RecordTypeDesc recordDescriptor, Value... nestedPatterns) {
+ public static PatternOps.RecordPatternOp recordPattern(RecordTypeRef recordDescriptor, Value... nestedPatterns) {
return recordPattern(recordDescriptor, List.of(nestedPatterns));
}
@@ -3140,7 +3140,7 @@ public static PatternOps.RecordPatternOp recordPattern(RecordTypeDesc recordDesc
* @param nestedPatterns the nested pattern values
* @return the record pattern operation
*/
- public static PatternOps.RecordPatternOp recordPattern(RecordTypeDesc recordDescriptor, List<Value> nestedPatterns) {
+ public static PatternOps.RecordPatternOp recordPattern(RecordTypeRef recordDescriptor, List<Value> nestedPatterns) {
return new PatternOps.RecordPatternOp(recordDescriptor, nestedPatterns);
}
}
diff --git a/src/java.base/share/classes/java/lang/reflect/code/parser/OpParser.java b/src/java.base/share/classes/java/lang/reflect/code/parser/OpParser.java
index ac6d024ed48..e4f1de491cf 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/parser/OpParser.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/parser/OpParser.java
@@ -47,7 +47,7 @@
import java.util.Map;
/**
- * A parser of serialized code models and descriptors from their textual form.
+ * A parser of serialized code models from their textual form.
* <p>
* The syntactic grammar of a code mode is specified in the grammar notation, and is a subset of the grammar,
* specified by the JLS, see section 2.4. (Except that we cannot express non-terminal symbols in italic type.)
@@ -260,7 +260,7 @@ static OpDefinition nodeToOpDef(OpNode opNode, TypeDefinition rtype, Context c,
static Body.Builder nodeToBody(BodyNode n, Context c, Body.Builder ancestorBody) {
Body.Builder body = Body.Builder.of(ancestorBody,
- // Create descriptor with just the return type and add parameters afterward
+ // Create function type with just the return type and add parameters afterward
FunctionType.functionType(c.typeFactory.constructType(n.rtype)));
Block.Builder eb = body.entryBlock();
diff --git a/src/java.base/share/classes/java/lang/reflect/code/parser/impl/DescParser.java b/src/java.base/share/classes/java/lang/reflect/code/parser/impl/DescParser.java
index 09d2f8fc08a..af35928d5df 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/parser/impl/DescParser.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/parser/impl/DescParser.java
@@ -25,12 +25,12 @@
package java.lang.reflect.code.parser.impl;
-import java.lang.reflect.code.descriptor.*;
-import java.lang.reflect.code.descriptor.impl.*;
-import java.lang.reflect.code.type.CoreTypeFactory;
+import java.lang.reflect.code.type.*;
import java.lang.reflect.code.TypeElement;
-import java.lang.reflect.code.type.FunctionType;
-import java.lang.reflect.code.type.TypeDefinition;
+import java.lang.reflect.code.type.RecordTypeRef;
+import java.lang.reflect.code.type.impl.FieldRefImpl;
+import java.lang.reflect.code.type.impl.MethodRefImpl;
+import java.lang.reflect.code.type.impl.RecordTypeRefImpl;
import java.util.ArrayList;
import java.util.List;
@@ -38,9 +38,9 @@ public final class DescParser {
private DescParser() {}
/**
- * Parse a type descriptor from its serialized textual form.
- * @param desc the serialized type descriptor
- * @return the type descriptor
+ * Parse a type definition from its serialized textual form.
+ * @param desc the serialized type definition
+ * @return the type definition
*/
public static TypeDefinition parseTypeDefinition(String desc) {
Scanner s = Scanner.factory().newScanner(desc);
@@ -49,39 +49,39 @@ public static TypeDefinition parseTypeDefinition(String desc) {
}
/**
- * Parse a method descriptor from its serialized textual form.
+ * Parse a method reference from its serialized textual form.
*
- * @param desc the serialized method descriptor
- * @return the method descriptor
+ * @param desc the serialized method reference
+ * @return the method reference
*/
- public static MethodDesc parseMethodDesc(String desc) {
+ public static MethodRef parseMethodRef(String desc) {
Scanner s = Scanner.factory().newScanner(desc);
s.nextToken();
- return parseMethodDesc(s);
+ return parseMethodRef(s);
}
/**
- * Parse a field descriptor from its serialized textual form.
+ * Parse a field reference from its serialized textual form.
*
- * @param desc the serialized field descriptor
- * @return the field descriptor
+ * @param desc the serialized field reference
+ * @return the field reference
*/
- public static FieldDesc parseFieldDesc(String desc) {
+ public static FieldRef parseFieldRef(String desc) {
Scanner s = Scanner.factory().newScanner(desc);
s.nextToken();
- return parseFieldDesc(s);
+ return parseFieldRef(s);
}
/**
- * Parse a record type descriptor from its serialized textual form.
+ * Parse a record type reference from its serialized textual form.
*
- * @param desc the serialized record type descriptor
- * @return the record type descriptor
+ * @param desc the serialized record type reference
+ * @return the record type reference
*/
- public static RecordTypeDesc parseRecordTypeDesc(String desc) {
+ public static RecordTypeRef parseRecordTypeRef(String desc) {
Scanner s = Scanner.factory().newScanner(desc);
s.nextToken();
- return parseRecordTypeDesc(s);
+ return parseRecordTypeRef(s);
}
public static TypeDefinition parseTypeDefinition(Lexer l) {
@@ -147,7 +147,7 @@ static FunctionType parseMethodType(Lexer l) {
return FunctionType.functionType(rtype, ptypes);
}
- static MethodDesc parseMethodDesc(Lexer l) {
+ static MethodRef parseMethodRef(Lexer l) {
TypeElement refType = parseTypeElement(l);
l.accept(Tokens.TokenKind.COLCOL);
@@ -164,10 +164,10 @@ static MethodDesc parseMethodDesc(Lexer l) {
FunctionType mtype = parseMethodType(l);
- return new MethodDescImpl(refType, methodName, mtype);
+ return new MethodRefImpl(refType, methodName, mtype);
}
- static FieldDesc parseFieldDesc(Lexer l) {
+ static FieldRef parseFieldRef(Lexer l) {
TypeElement refType = parseTypeElement(l);
l.accept(Tokens.TokenKind.COLCOL);
@@ -178,22 +178,22 @@ static FieldDesc parseFieldDesc(Lexer l) {
if (!mtype.parameterTypes().isEmpty()) {
throw new IllegalArgumentException();
}
- return new FieldDescImpl(refType, fieldName, mtype.returnType());
+ return new FieldRefImpl(refType, fieldName, mtype.returnType());
}
- static RecordTypeDesc parseRecordTypeDesc(Lexer l) {
- List<RecordTypeDesc.ComponentDesc> components = new ArrayList<>();
+ static RecordTypeRef parseRecordTypeRef(Lexer l) {
+ List<RecordTypeRef.ComponentRef> components = new ArrayList<>();
l.accept(Tokens.TokenKind.LPAREN);
if (l.token().kind != Tokens.TokenKind.RPAREN) {
do {
TypeElement componentType = parseTypeElement(l);
String componentName = l.accept(Tokens.TokenKind.IDENTIFIER).name();
- components.add(new RecordTypeDesc.ComponentDesc(componentType, componentName));
+ components.add(new RecordTypeRef.ComponentRef(componentType, componentName));
} while(l.acceptIf(Tokens.TokenKind.COMMA));
}
l.accept(Tokens.TokenKind.RPAREN);
TypeElement recordType = parseTypeElement(l);
- return new RecordTypeDescImpl(recordType, components);
+ return new RecordTypeRefImpl(recordType, components);
}
}
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/FieldDesc.java b/src/java.base/share/classes/java/lang/reflect/code/type/FieldRef.java
similarity index 76%
rename from src/java.base/share/classes/java/lang/reflect/code/descriptor/FieldDesc.java
rename to src/java.base/share/classes/java/lang/reflect/code/type/FieldRef.java
index 0a52403d352..c704d3388cb 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/FieldDesc.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/FieldRef.java
@@ -23,19 +23,18 @@
* questions.
*/
-package java.lang.reflect.code.descriptor;
+package java.lang.reflect.code.type;
-import java.lang.reflect.code.descriptor.impl.FieldDescImpl;
+import java.lang.reflect.code.type.impl.FieldRefImpl;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.reflect.Field;
-import java.lang.reflect.code.type.JavaType;
import java.lang.reflect.code.TypeElement;
/**
- * The symbolic description of a Java field.
+ * The symbolic reference to a Java field.
*/
-public sealed interface FieldDesc permits FieldDescImpl {
+public sealed interface FieldRef permits FieldRefImpl {
TypeElement refType();
String name();
@@ -50,20 +49,20 @@ public sealed interface FieldDesc permits FieldDescImpl {
// Factories
- static FieldDesc field(Field f) {
+ static FieldRef field(Field f) {
return field(f.getDeclaringClass(), f.getName(), f.getType());
}
- static FieldDesc field(Class<?> refType, String name, Class<?> type) {
+ static FieldRef field(Class<?> refType, String name, Class<?> type) {
return field(JavaType.type(refType), name, JavaType.type(type));
}
- static FieldDesc field(TypeElement refType, String name, TypeElement type) {
- return new FieldDescImpl(refType, name, type);
+ static FieldRef field(TypeElement refType, String name, TypeElement type) {
+ return new FieldRefImpl(refType, name, type);
}
// Copied code in jdk.compiler module throws UOE
- static FieldDesc ofString(String s) {
-/*__throw new UnsupportedOperationException();__*/ return java.lang.reflect.code.parser.impl.DescParser.parseFieldDesc(s);
+ static FieldRef ofString(String s) {
+/*__throw new UnsupportedOperationException();__*/ return java.lang.reflect.code.parser.impl.DescParser.parseFieldRef(s);
}
}
\ No newline at end of file
diff --git a/src/java.base/share/classes/java/lang/reflect/code/type/JavaType.java b/src/java.base/share/classes/java/lang/reflect/code/type/JavaType.java
index aa38fad622e..bc959db4a1d 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/type/JavaType.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/JavaType.java
@@ -195,7 +195,7 @@ static JavaType type(JavaType t, JavaType... typeArguments) {
static JavaType type(JavaType t, List<JavaType> typeArguments) {
if (t.hasTypeArguments()) {
- throw new IllegalArgumentException("Type descriptor must not have type arguments: " + t);
+ throw new IllegalArgumentException("Type must not have type arguments: " + t);
}
JavaTypeImpl timpl = (JavaTypeImpl) t;
return new JavaTypeImpl(timpl.type, timpl.dims, typeArguments);
@@ -207,10 +207,10 @@ static JavaType type(JavaType t, int dims, JavaType... typeArguments) {
static JavaType type(JavaType t, int dims, List<JavaType> typeArguments) {
if (t.isArray()) {
- throw new IllegalArgumentException("Type descriptor must not be an array: " + t);
+ throw new IllegalArgumentException("Type must not be an array: " + t);
}
if (t.hasTypeArguments()) {
- throw new IllegalArgumentException("Type descriptor must not have type arguments: " + t);
+ throw new IllegalArgumentException("Type must not have type arguments: " + t);
}
JavaTypeImpl timpl = (JavaTypeImpl) t;
return new JavaTypeImpl(timpl.type, dims, typeArguments);
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/MethodDesc.java b/src/java.base/share/classes/java/lang/reflect/code/type/MethodRef.java
similarity index 75%
rename from src/java.base/share/classes/java/lang/reflect/code/descriptor/MethodDesc.java
rename to src/java.base/share/classes/java/lang/reflect/code/type/MethodRef.java
index f67661d9949..6a464d3d9df 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/MethodDesc.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/MethodRef.java
@@ -23,25 +23,23 @@
* questions.
*/
-package java.lang.reflect.code.descriptor;
+package java.lang.reflect.code.type;
import java.lang.constant.ClassDesc;
import java.lang.constant.MethodTypeDesc;
-import java.lang.reflect.code.descriptor.impl.MethodDescImpl;
+import java.lang.reflect.code.type.impl.MethodRefImpl;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
-import java.lang.reflect.code.type.FunctionType;
-import java.lang.reflect.code.type.JavaType;
import java.lang.reflect.code.TypeElement;
import java.util.List;
import static java.lang.reflect.code.type.FunctionType.functionType;
/**
- * The symbolic description of a Java method.
+ * The symbolic reference to a Java method.
*/
// @@@ require invoke kind:
// special, static, virtual
@@ -51,7 +49,7 @@
// constant pool entry of CONSTANT_Methodref_info or CONSTANT_InterfaceMethodref_info.
//
// We can infer the kind, if we can resolve the types and lookup the declared method
-public sealed interface MethodDesc permits MethodDescImpl {
+public sealed interface MethodRef permits MethodRefImpl {
TypeElement refType();
@@ -67,38 +65,38 @@ public sealed interface MethodDesc permits MethodDescImpl {
// Factories
- static MethodDesc method(Method m) {
+ static MethodRef method(Method m) {
return method(m.getDeclaringClass(), m.getName(), m.getReturnType(), m.getParameterTypes());
}
- static MethodDesc method(Class<?> refType, String name, MethodType mt) {
+ static MethodRef method(Class<?> refType, String name, MethodType mt) {
return method(refType, name, mt.returnType(), mt.parameterList());
}
- static MethodDesc method(Class<?> refType, String name, Class<?> retType, Class<?>... params) {
+ static MethodRef method(Class<?> refType, String name, Class<?> retType, Class<?>... params) {
return method(refType, name, retType, List.of(params));
}
- static MethodDesc method(Class<?> refType, String name, Class<?> retType, List<Class<?>> params) {
+ static MethodRef method(Class<?> refType, String name, Class<?> retType, List<Class<?>> params) {
return method(JavaType.type(refType), name, JavaType.type(retType), params.stream().map(JavaType::type).toList());
}
- static MethodDesc method(TypeElement refType, String name, FunctionType type) {
- return new MethodDescImpl(refType, name, type);
+ static MethodRef method(TypeElement refType, String name, FunctionType type) {
+ return new MethodRefImpl(refType, name, type);
}
- static MethodDesc method(TypeElement refType, String name, TypeElement retType, TypeElement... params) {
+ static MethodRef method(TypeElement refType, String name, TypeElement retType, TypeElement... params) {
return method(refType, name, functionType(retType, params));
}
- static MethodDesc method(TypeElement refType, String name, TypeElement retType, List<? extends TypeElement> params) {
+ static MethodRef method(TypeElement refType, String name, TypeElement retType, List<? extends TypeElement> params) {
return method(refType, name, functionType(retType, params));
}
// Copied code in jdk.compiler module throws UOE
- static MethodDesc ofString(String s) {
-/*__throw new UnsupportedOperationException();__*/ return java.lang.reflect.code.parser.impl.DescParser.parseMethodDesc(s);
+ static MethodRef ofString(String s) {
+/*__throw new UnsupportedOperationException();__*/ return java.lang.reflect.code.parser.impl.DescParser.parseMethodRef(s);
}
@@ -114,7 +112,7 @@ static FunctionType ofNominalDescriptor(MethodTypeDesc d) {
static MethodTypeDesc toNominalDescriptor(FunctionType t) {
return MethodTypeDesc.of(
toClassDesc(t.returnType()),
- t.parameterTypes().stream().map(MethodDesc::toClassDesc).toList());
+ t.parameterTypes().stream().map(MethodRef::toClassDesc).toList());
}
private static ClassDesc toClassDesc(TypeElement e) {
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/RecordTypeDesc.java b/src/java.base/share/classes/java/lang/reflect/code/type/RecordTypeRef.java
similarity index 62%
rename from src/java.base/share/classes/java/lang/reflect/code/descriptor/RecordTypeDesc.java
rename to src/java.base/share/classes/java/lang/reflect/code/type/RecordTypeRef.java
index c264a58e814..78bc89440c6 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/RecordTypeDesc.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/RecordTypeRef.java
@@ -23,50 +23,49 @@
* questions.
*/
-package java.lang.reflect.code.descriptor;
+package java.lang.reflect.code.type;
-import java.lang.reflect.code.descriptor.impl.RecordTypeDescImpl;
-import java.lang.reflect.code.type.JavaType;
+import java.lang.reflect.code.type.impl.RecordTypeRefImpl;
import java.lang.reflect.code.TypeElement;
import java.util.List;
import java.util.stream.Stream;
/**
- * The symbolic description of a Java record type.
+ * The symbolic reference to a Java record type.
*/
-public sealed interface RecordTypeDesc permits RecordTypeDescImpl {
+public sealed interface RecordTypeRef permits RecordTypeRefImpl {
TypeElement recordType();
/**
- * The symbolic description a Java record component.
+ * The symbolic reference to a Java record component.
* @param type the type of the component
* @param name the name of the component
*/
- record ComponentDesc(TypeElement type, String name) {}
+ record ComponentRef(TypeElement type, String name) {}
- List<ComponentDesc> components();
+ List<ComponentRef> components();
- MethodDesc methodForComponent(int i);
+ MethodRef methodForComponent(int i);
// Factories
- static RecordTypeDesc recordType(Class<? extends Record> c) {
- List<ComponentDesc> components = Stream.of(c.getRecordComponents())
- .map(rc -> new ComponentDesc(JavaType.type(rc.getType()), rc.getName()))
+ static RecordTypeRef recordType(Class<? extends Record> c) {
+ List<ComponentRef> components = Stream.of(c.getRecordComponents())
+ .map(rc -> new ComponentRef(JavaType.type(rc.getType()), rc.getName()))
.toList();
return recordType(JavaType.type(c), components);
}
- static RecordTypeDesc recordType(TypeElement recordType, ComponentDesc... components) {
+ static RecordTypeRef recordType(TypeElement recordType, ComponentRef... components) {
return recordType(recordType, List.of(components));
}
- static RecordTypeDesc recordType(TypeElement recordType, List<ComponentDesc> components) {
- return new RecordTypeDescImpl(recordType, components);
+ static RecordTypeRef recordType(TypeElement recordType, List<ComponentRef> components) {
+ return new RecordTypeRefImpl(recordType, components);
}
// Copied code in jdk.compiler module throws UOE
- static RecordTypeDesc ofString(String s) {
-/*__throw new UnsupportedOperationException();__*/ return java.lang.reflect.code.parser.impl.DescParser.parseRecordTypeDesc(s);
+ static RecordTypeRef ofString(String s) {
+/*__throw new UnsupportedOperationException();__*/ return java.lang.reflect.code.parser.impl.DescParser.parseRecordTypeRef(s);
}
}
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/FieldDescImpl.java b/src/java.base/share/classes/java/lang/reflect/code/type/impl/FieldRefImpl.java
similarity index 93%
rename from src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/FieldDescImpl.java
rename to src/java.base/share/classes/java/lang/reflect/code/type/impl/FieldRefImpl.java
index 40d3c41670a..177a9833d97 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/FieldDescImpl.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/impl/FieldRefImpl.java
@@ -23,21 +23,21 @@
* questions.
*/
-package java.lang.reflect.code.descriptor.impl;
+package java.lang.reflect.code.type.impl;
-import java.lang.reflect.code.descriptor.FieldDesc;
+import java.lang.reflect.code.type.FieldRef;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.reflect.Field;
import java.lang.reflect.code.type.JavaType;
import java.lang.reflect.code.TypeElement;
-public final class FieldDescImpl implements FieldDesc {
+public final class FieldRefImpl implements FieldRef {
final TypeElement refType;
final String name;
final TypeElement type;
- public FieldDescImpl(TypeElement refType, String name, TypeElement type) {
+ public FieldRefImpl(TypeElement refType, String name, TypeElement type) {
this.refType = refType;
this.name = name;
this.type = type;
@@ -121,7 +121,7 @@ public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
- FieldDescImpl fieldDesc = (FieldDescImpl) o;
+ FieldRefImpl fieldDesc = (FieldRefImpl) o;
if (!refType.equals(fieldDesc.refType)) return false;
if (!name.equals(fieldDesc.name)) return false;
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/MethodDescImpl.java b/src/java.base/share/classes/java/lang/reflect/code/type/impl/MethodRefImpl.java
similarity index 91%
rename from src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/MethodDescImpl.java
rename to src/java.base/share/classes/java/lang/reflect/code/type/impl/MethodRefImpl.java
index 6c6df090393..cd1af55f7c5 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/MethodDescImpl.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/impl/MethodRefImpl.java
@@ -23,9 +23,9 @@
* questions.
*/
-package java.lang.reflect.code.descriptor.impl;
+package java.lang.reflect.code.type.impl;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandleInfo;
import java.lang.invoke.MethodHandles;
@@ -37,12 +37,12 @@
import static java.util.stream.Collectors.joining;
-public final class MethodDescImpl implements MethodDesc {
+public final class MethodRefImpl implements MethodRef {
final TypeElement refType;
final String name;
final FunctionType type;
- public MethodDescImpl(TypeElement refType, String name, FunctionType type) {
+ public MethodRefImpl(TypeElement refType, String name, FunctionType type) {
this.refType = refType;
this.name = name;
this.type = type;
@@ -74,7 +74,7 @@ public MethodHandle resolveToHandle(MethodHandles.Lookup l) throws ReflectiveOpe
// @@@ kind
Class<?> refC = resolve(l, refType);
- MethodType mt = MethodDesc.toNominalDescriptor(type).resolveConstantDesc(l);
+ MethodType mt = MethodRef.toNominalDescriptor(type).resolveConstantDesc(l);
MethodHandle mh = null;
ReflectiveOperationException c = null;
@@ -123,7 +123,7 @@ public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
- MethodDescImpl that = (MethodDescImpl) o;
+ MethodRefImpl that = (MethodRefImpl) o;
if (!refType.equals(that.refType)) return false;
if (!name.equals(that.name)) return false;
diff --git a/src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/RecordTypeDescImpl.java b/src/java.base/share/classes/java/lang/reflect/code/type/impl/RecordTypeRefImpl.java
similarity index 77%
rename from src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/RecordTypeDescImpl.java
rename to src/java.base/share/classes/java/lang/reflect/code/type/impl/RecordTypeRefImpl.java
index b61546dac5b..c2f86dd6491 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/descriptor/impl/RecordTypeDescImpl.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/impl/RecordTypeRefImpl.java
@@ -23,20 +23,20 @@
* questions.
*/
-package java.lang.reflect.code.descriptor.impl;
+package java.lang.reflect.code.type.impl;
-import java.lang.reflect.code.descriptor.MethodDesc;
-import java.lang.reflect.code.descriptor.RecordTypeDesc;
+import java.lang.reflect.code.type.MethodRef;
+import java.lang.reflect.code.type.RecordTypeRef;
import java.lang.reflect.code.TypeElement;
import java.util.List;
import static java.util.stream.Collectors.joining;
-public final class RecordTypeDescImpl implements RecordTypeDesc {
+public final class RecordTypeRefImpl implements RecordTypeRef {
final TypeElement recordType;
- final List<ComponentDesc> components;
+ final List<ComponentRef> components;
- public RecordTypeDescImpl(TypeElement recordType, List<ComponentDesc> components) {
+ public RecordTypeRefImpl(TypeElement recordType, List<ComponentRef> components) {
this.recordType = recordType;
this.components = List.copyOf(components);
}
@@ -47,18 +47,18 @@ public TypeElement recordType() {
}
@Override
- public List<ComponentDesc> components() {
+ public List<ComponentRef> components() {
return components;
}
@Override
- public MethodDesc methodForComponent(int i) {
+ public MethodRef methodForComponent(int i) {
if (i < 0 || i >= components.size()) {
throw new IndexOutOfBoundsException();
}
- ComponentDesc c = components.get(i);
- return MethodDesc.method(recordType, c.name(), c.type());
+ ComponentRef c = components.get(i);
+ return MethodRef.method(recordType, c.name(), c.type());
}
@Override
diff --git a/src/java.base/share/classes/java/lang/reflect/code/type/package-info.java b/src/java.base/share/classes/java/lang/reflect/code/type/package-info.java
index 6f6e53cf3f8..af07f8d6459 100644
--- a/src/java.base/share/classes/java/lang/reflect/code/type/package-info.java
+++ b/src/java.base/share/classes/java/lang/reflect/code/type/package-info.java
@@ -24,6 +24,6 @@
*/
/**
- * Types for code models.
+ * Types and symbolic references for code models.
*/
package java.lang.reflect.code.type;
\ No newline at end of file
diff --git a/src/java.base/share/classes/module-info.java b/src/java.base/share/classes/module-info.java
index 4d99a57c01a..1b07f27bae7 100644
--- a/src/java.base/share/classes/module-info.java
+++ b/src/java.base/share/classes/module-info.java
@@ -93,7 +93,6 @@
exports java.lang.reflect.code;
exports java.lang.reflect.code.analysis;
exports java.lang.reflect.code.bytecode;
- exports java.lang.reflect.code.descriptor;
exports java.lang.reflect.code.interpreter;
exports java.lang.reflect.code.op;
exports java.lang.reflect.code.parser;
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ReflectMethods.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ReflectMethods.java
index 918bc3d1cc3..a38fad604ce 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ReflectMethods.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ReflectMethods.java
@@ -81,13 +81,7 @@
import jdk.internal.java.lang.reflect.code.*;
import jdk.internal.java.lang.reflect.code.op.CoreOps;
import jdk.internal.java.lang.reflect.code.op.ExtendedOps;
-import jdk.internal.java.lang.reflect.code.descriptor.FieldDesc;
-import jdk.internal.java.lang.reflect.code.descriptor.MethodDesc;
-import jdk.internal.java.lang.reflect.code.descriptor.RecordTypeDesc;
-import jdk.internal.java.lang.reflect.code.type.FunctionType;
-import jdk.internal.java.lang.reflect.code.type.JavaType;
-import jdk.internal.java.lang.reflect.code.type.TupleType;
-import jdk.internal.java.lang.reflect.code.type.VarType;
+import jdk.internal.java.lang.reflect.code.type.*;
import jdk.internal.java.lang.reflect.code.type.impl.JavaTypeImpl;
import javax.lang.model.element.Modifier;
@@ -651,7 +645,7 @@ Value convert(Value exprVal, Type target) {
}
Value box(Value valueExpr, Type box) {
- MethodDesc boxMethod = MethodDesc.method(typeToTypeElement(box), names.valueOf.toString(),
+ MethodRef boxMethod = MethodRef.method(typeToTypeElement(box), names.valueOf.toString(),
FunctionType.functionType(typeToTypeElement(box), typeToTypeElement(types.unboxedType(box))));
return append(CoreOps.invoke(boxMethod, valueExpr));
}
@@ -662,7 +656,7 @@ Value unbox(Value valueExpr, Type box, Type primitive, Type unboxedType) {
unboxedType = primitive;
valueExpr = append(CoreOps.cast(typeToTypeElement(types.boxedClass(unboxedType).type), valueExpr));
}
- MethodDesc unboxMethod = MethodDesc.method(typeToTypeElement(box),
+ MethodRef unboxMethod = MethodRef.method(typeToTypeElement(box),
unboxedType.tsym.name.append(names.Value).toString(),
FunctionType.functionType(typeToTypeElement(unboxedType), typeToTypeElement(box)));
return append(CoreOps.invoke(unboxMethod, valueExpr));
@@ -705,7 +699,7 @@ public void visitAssign(JCAssign tree) {
append(CoreOps.varStore(varOp, result));
}
case FIELD -> {
- FieldDesc fd = symbolToFieldDesc(sym, symbolSiteType(sym));
+ FieldRef fd = symbolToFieldRef(sym, symbolSiteType(sym));
if (sym.isStatic()) {
append(CoreOps.fieldStore(fd, result));
} else {
@@ -728,11 +722,11 @@ public void visitAssign(JCAssign tree) {
result = toValue(tree.rhs, target);
Symbol sym = assign.sym;
- FieldDesc fd = symbolToFieldDesc(sym, assign.selected.type);
+ FieldRef fr = symbolToFieldRef(sym, assign.selected.type);
if (sym.isStatic()) {
- append(CoreOps.fieldStore(fd, result));
+ append(CoreOps.fieldStore(fr, result));
} else {
- append(CoreOps.fieldStore(fd, receiver, result));
+ append(CoreOps.fieldStore(fr, receiver, result));
}
break;
}
@@ -798,22 +792,22 @@ void applyCompoundAssign(JCTree.JCExpression lhs, Function<Value, Value> scanRhs
append(CoreOps.varStore(varOp, r));
}
case FIELD -> {
- FieldDesc fd = symbolToFieldDesc(sym, symbolSiteType(sym));
+ FieldRef fr = symbolToFieldRef(sym, symbolSiteType(sym));
Op.Result lhsOpValue;
TypeElement resultType = typeToTypeElement(sym.type);
if (sym.isStatic()) {
- lhsOpValue = append(CoreOps.fieldLoad(resultType, fd));
+ lhsOpValue = append(CoreOps.fieldLoad(resultType, fr));
} else {
- lhsOpValue = append(CoreOps.fieldLoad(resultType, fd, thisValue()));
+ lhsOpValue = append(CoreOps.fieldLoad(resultType, fr, thisValue()));
}
// Scan the rhs
Value r = scanRhs.apply(lhsOpValue);
if (sym.isStatic()) {
- append(CoreOps.fieldStore(fd, r));
+ append(CoreOps.fieldStore(fr, r));
} else {
- append(CoreOps.fieldStore(fd, thisValue(), r));
+ append(CoreOps.fieldStore(fr, thisValue(), r));
}
}
default -> {
@@ -828,22 +822,22 @@ void applyCompoundAssign(JCTree.JCExpression lhs, Function<Value, Value> scanRhs
Value receiver = toValue(assign.selected);
Symbol sym = assign.sym;
- FieldDesc fd = symbolToFieldDesc(sym, assign.selected.type);
+ FieldRef fr = symbolToFieldRef(sym, assign.selected.type);
Op.Result lhsOpValue;
TypeElement resultType = typeToTypeElement(sym.type);
if (sym.isStatic()) {
- lhsOpValue = append(CoreOps.fieldLoad(resultType, fd));
+ lhsOpValue = append(CoreOps.fieldLoad(resultType, fr));
} else {
- lhsOpValue = append(CoreOps.fieldLoad(resultType, fd, receiver));
+ lhsOpValue = append(CoreOps.fieldLoad(resultType, fr, receiver));
}
// Scan the rhs
Value r = scanRhs.apply(lhsOpValue);
if (sym.isStatic()) {
- append(CoreOps.fieldStore(fd, r));
+ append(CoreOps.fieldStore(fr, r));
} else {
- append(CoreOps.fieldStore(fd, receiver, r));
+ append(CoreOps.fieldStore(fr, receiver, r));
}
}
case INDEXED -> {
@@ -882,12 +876,12 @@ public void visitIdent(JCIdent tree) {
if (sym.name.equals(names._this)) {
result = thisValue();
} else {
- FieldDesc fd = symbolToFieldDesc(sym, symbolSiteType(sym));
+ FieldRef fr = symbolToFieldRef(sym, symbolSiteType(sym));
TypeElement resultType = typeToTypeElement(sym.type);
if (sym.isStatic()) {
- result = append(CoreOps.fieldLoad(resultType, fd));
+ result = append(CoreOps.fieldLoad(resultType, fr));
} else {
- result = append(CoreOps.fieldLoad(resultType, fd, thisValue()));
+ result = append(CoreOps.fieldLoad(resultType, fr, thisValue()));
}
}
}
@@ -932,13 +926,13 @@ public void visitSelect(JCFieldAccess tree) {
Symbol sym = tree.sym;
switch (sym.getKind()) {
case FIELD, ENUM_CONSTANT -> {
- FieldDesc fd = symbolToFieldDesc(sym, qualifierTarget.hasTag(NONE) ?
+ FieldRef fr = symbolToFieldRef(sym, qualifierTarget.hasTag(NONE) ?
tree.selected.type : qualifierTarget);
TypeElement resultType = typeToTypeElement(types.memberType(tree.selected.type, sym));
if (sym.isStatic()) {
- result = append(CoreOps.fieldLoad(resultType, fd));
+ result = append(CoreOps.fieldLoad(resultType, fr));
} else {
- result = append(CoreOps.fieldLoad(resultType, fd, receiver));
+ result = append(CoreOps.fieldLoad(resultType, fr, receiver));
}
}
case INTERFACE, CLASS, ENUM -> {
@@ -971,7 +965,7 @@ public void visitApply(JCTree.JCMethodInvocation tree) {
// @@@ super.xyz(...) calls
// Modeling with a call operation would result in the receiver type differing from that
- // in the method descriptor, perhaps that is sufficient?
+ // in the method reference, perhaps that is sufficient?
JCTree meth = TreeInfo.skipParens(tree.meth);
switch (meth.getTag()) {
@@ -986,8 +980,8 @@ public void visitApply(JCTree.JCMethodInvocation tree) {
args.addAll(scanMethodArguments(tree.args, tree.meth.type, tree.varargsElement));
- MethodDesc md = symbolToErasedMethodDesc(sym, symbolSiteType(sym));
- Value res = append(CoreOps.invoke(typeToTypeElement(meth.type.getReturnType()), md, args));
+ MethodRef mr = symbolToErasedMethodRef(sym, symbolSiteType(sym));
+ Value res = append(CoreOps.invoke(typeToTypeElement(meth.type.getReturnType()), mr, args));
if (sym.type.getReturnType().getTag() != TypeTag.VOID) {
result = res;
}
@@ -1007,9 +1001,9 @@ public void visitApply(JCTree.JCMethodInvocation tree) {
args.addAll(scanMethodArguments(tree.args, tree.meth.type, tree.varargsElement));
- MethodDesc md = symbolToErasedMethodDesc(sym, qualifierTarget.hasTag(NONE) ?
+ MethodRef mr = symbolToErasedMethodRef(sym, qualifierTarget.hasTag(NONE) ?
access.selected.type : qualifierTarget);
- Value res = append(CoreOps.invoke(typeToTypeElement(meth.type.getReturnType()), md, args));
+ Value res = append(CoreOps.invoke(typeToTypeElement(meth.type.getReturnType()), mr, args));
if (sym.type.getReturnType().getTag() != TypeTag.VOID) {
result = res;
}
@@ -1076,8 +1070,8 @@ public void visitTypeCast(JCTree.JCTypeCast tree) {
result = v;
} else {
// Reference cast
- JavaType descriptor = typeToTypeElement(types.erasure(type));
- result = append(CoreOps.cast(typeToTypeElement(type), descriptor, v));
+ JavaType jt = typeToTypeElement(types.erasure(type));
+ result = append(CoreOps.cast(typeToTypeElement(type), jt, v));
}
}
@@ -1135,7 +1129,7 @@ public void visitRecordPattern(JCTree.JCRecordPattern record) {
nestedValues.add(toValue(jcPattern));
}
- result = append(ExtendedOps.recordPattern(symbolToRecordTypeDesc(record.record), nestedValues));
+ result = append(ExtendedOps.recordPattern(symbolToRecordTypeRef(record.record), nestedValues));
}
Value toValue(JCTree tree) {
@@ -1208,13 +1202,13 @@ public void visitNewClass(JCTree.JCNewClass tree) {
args.add(outerInstance);
}
- // Create erased method type descriptor for constructor, where
+ // Create erased method type reference for constructor, where
// the return type declares the class to instantiate
// @@@ require symbol site type?
- MethodDesc methodDesc = symbolToErasedMethodDesc(tree.constructor);
+ MethodRef methodRef = symbolToErasedMethodRef(tree.constructor);
FunctionType constructorType = FunctionType.functionType(
symbolToErasedDesc(tree.constructor.owner),
- methodDesc.type().parameterTypes());
+ methodRef.type().parameterTypes());
args.addAll(scanMethodArguments(tree.args, tree.constructorType, tree.varargsElement));
@@ -1441,7 +1435,7 @@ public void visitSwitchExpression(JCTree.JCSwitchExpression tree) {
localResult = append(CoreOps.eq(localTarget, expr));
} else {
localResult = append(CoreOps.invoke(
- MethodDesc.method(Objects.class, "equals", boolean.class, Object.class, Object.class),
+ MethodRef.method(Objects.class, "equals", boolean.class, Object.class, Object.class),
localTarget, expr));
}
} else {
@@ -1457,7 +1451,7 @@ public void visitSwitchExpression(JCTree.JCSwitchExpression tree) {
labelResult = append(CoreOps.eq(localTarget, expr));
} else {
labelResult = append(CoreOps.invoke(
- MethodDesc.method(Objects.class, "equals", boolean.class, Object.class, Object.class),
+ MethodRef.method(Objects.class, "equals", boolean.class, Object.class, Object.class),
localTarget, expr));
}
@@ -2215,38 +2209,38 @@ Type symbolSiteType(Symbol s) {
return isMember ? currentClassSym.type : s.owner.type;
}
- FieldDesc symbolToFieldDesc(Symbol s, Type site) {
+ FieldRef symbolToFieldRef(Symbol s, Type site) {
// @@@ Made Gen::binaryQualifier public, duplicate logic?
- // Ensure correct qualifying class is used in descriptor, see JLS 13.1
+ // Ensure correct qualifying class is used in the reference, see JLS 13.1
// https://docs.oracle.com/javase/specs/jls/se20/html/jls-13.html#jls-13.1
- return symbolToFieldDesc(gen.binaryQualifier(s, site));
+ return symbolToFieldRef(gen.binaryQualifier(s, site));
}
- FieldDesc symbolToFieldDesc(Symbol s) {
- return FieldDesc.field(
+ FieldRef symbolToFieldRef(Symbol s) {
+ return FieldRef.field(
typeToTypeElement(s.owner.type),
s.name.toString(),
typeToTypeElement(s.type));
}
- MethodDesc symbolToMethodDesc(Symbol s) {
- return MethodDesc.method(
+ MethodRef symbolToMethodRef(Symbol s) {
+ return MethodRef.method(
typeToTypeElement(s.owner.type),
s.name.toString(),
typeToTypeElement(s.type.getReturnType()),
s.type.getParameterTypes().stream().map(this::typeToTypeElement).toArray(TypeElement[]::new));
}
- MethodDesc symbolToErasedMethodDesc(Symbol s, Type site) {
+ MethodRef symbolToErasedMethodRef(Symbol s, Type site) {
// @@@ Made Gen::binaryQualifier public, duplicate logic?
- // Ensure correct qualifying class is used in descriptor, see JLS 13.1
+ // Ensure correct qualifying class is used in the reference, see JLS 13.1
// https://docs.oracle.com/javase/specs/jls/se20/html/jls-13.html#jls-13.1
- return symbolToErasedMethodDesc(gen.binaryQualifier(s, site));
+ return symbolToErasedMethodRef(gen.binaryQualifier(s, site));
}
- MethodDesc symbolToErasedMethodDesc(Symbol s) {
+ MethodRef symbolToErasedMethodRef(Symbol s) {
Type erasedType = s.erasure(types);
- return MethodDesc.method(
+ return MethodRef.method(
typeToTypeElement(s.owner.erasure(types)),
s.name.toString(),
typeToTypeElement(erasedType.getReturnType()),
@@ -2263,12 +2257,12 @@ FunctionType typeToFunctionType(Type t) {
t.getParameterTypes().stream().map(this::typeToTypeElement).toArray(TypeElement[]::new));
}
- RecordTypeDesc symbolToRecordTypeDesc(Symbol.ClassSymbol s) {
+ RecordTypeRef symbolToRecordTypeRef(Symbol.ClassSymbol s) {
TypeElement recordType = typeToTypeElement(s.type);
- List<RecordTypeDesc.ComponentDesc> components = s.getRecordComponents().stream()
- .map(rc -> new RecordTypeDesc.ComponentDesc(typeToTypeElement(rc.type), rc.name.toString()))
+ List<RecordTypeRef.ComponentRef> components = s.getRecordComponents().stream()
+ .map(rc -> new RecordTypeRef.ComponentRef(typeToTypeElement(rc.type), rc.name.toString()))
.toList();
- return RecordTypeDesc.recordType(recordType, components);
+ return RecordTypeRef.recordType(recordType, components);
}
Op defaultValue(Type t) {
@@ -2317,7 +2311,7 @@ public boolean checkDenotableInTypeDesc(Type t) {
/**
* A type visitor that descends into the given type looking for types that are non-denotable
- * in IR type descriptors. Examples of such types are: type-variables (regular or captured),
+ * in code model types. Examples of such types are: type-variables (regular or captured),
* wildcard type argument, intersection types, union types. The visit methods return false
* as soon as a non-denotable type is encountered and true otherwise. (see {@link Check#checkDenotable(Type)}.
*/
@@ -2329,7 +2323,7 @@ public Boolean visitType(Type t, Void s) {
@Override
public Boolean visitClassType(ClassType t, Void s) {
if (t.isUnion() || t.isIntersection()) {
- // union an intersections cannot be denoted in IR type descriptors
+ // union and intersections cannot be denoted in code model types
return false;
}
// @@@ What about enclosing types?
@@ -2344,13 +2338,13 @@ public Boolean visitClassType(ClassType t, Void s) {
@Override
public Boolean visitTypeVar(TypeVar t, Void s) {
- // type variables cannot be denoted in IR type descriptors
+ // type variables cannot be denoted in code model types
return false;
}
@Override
public Boolean visitWildcardType(WildcardType t, Void s) {
- // wildcards cannot de denoted in IR type descriptors
+ // wildcards cannot de denoted in code model types
return false;
}
diff --git a/test/jdk/java/lang/reflect/code/TestClosureOps.java b/test/jdk/java/lang/reflect/code/TestClosureOps.java
index 9b25bef4c9b..2c812ec9004 100644
--- a/test/jdk/java/lang/reflect/code/TestClosureOps.java
+++ b/test/jdk/java/lang/reflect/code/TestClosureOps.java
@@ -33,7 +33,7 @@
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.Op;
import java.lang.reflect.code.Quoted;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.interpreter.Interpreter;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.code.type.JavaType;
@@ -52,7 +52,7 @@
public class TestClosureOps {
static class Builder {
- static final MethodDesc ACCEPT_METHOD = MethodDesc.method(type(TestClosureOps.Builder.class), "accept",
+ static final MethodRef ACCEPT_METHOD = MethodRef.method(type(TestClosureOps.Builder.class), "accept",
INT, CoreOps.QuotedOp.QUOTED_TYPE);
static int accept(Quoted c) {
@@ -67,12 +67,12 @@ static int accept(Quoted c) {
@Test
public void testQuotedWithCapture() {
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(block -> {
Block.Parameter i = block.parameters().get(0);
- // functional descriptor = (int)int
+ // functional type = (int)int
// op descriptor = ()Quoted<ClosureOp>
CoreOps.QuotedOp qop = quoted(block.parentBody(), qblock -> {
return closure(qblock.parentBody(), functionType(INT, INT))
@@ -99,12 +99,12 @@ public void testQuotedWithCapture() {
@Test
public void testWithCapture() {
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(block -> {
Block.Parameter i = block.parameters().get(0);
- // functional descriptor = (int)int
+ // functional type = (int)int
// captures i
CoreOps.ClosureOp closure = CoreOps.closure(block.parentBody(),
functionType(INT, INT))
diff --git a/test/jdk/java/lang/reflect/code/TestExceptionRegionOps.java b/test/jdk/java/lang/reflect/code/TestExceptionRegionOps.java
index 80831c80767..d61ca16e0d9 100644
--- a/test/jdk/java/lang/reflect/code/TestExceptionRegionOps.java
+++ b/test/jdk/java/lang/reflect/code/TestExceptionRegionOps.java
@@ -30,7 +30,7 @@
import org.testng.annotations.Test;
import java.lang.reflect.code.op.CoreOps;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.interpreter.Interpreter;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.code.type.JavaType;
@@ -465,7 +465,7 @@ public void testCatchFinally() {
});
}
- static final MethodDesc INT_CONSUMER_ACCEPT_METHOD = MethodDesc.method(type(IntConsumer.class), "accept",
+ static final MethodRef INT_CONSUMER_ACCEPT_METHOD = MethodRef.method(type(IntConsumer.class), "accept",
VOID, INT);
static Consumer<IntConsumer> testConsumer(Consumer<IntConsumer> actualR, Consumer<IntConsumer> expectedR) {
diff --git a/test/jdk/java/lang/reflect/code/TestInline.java b/test/jdk/java/lang/reflect/code/TestInline.java
index 53ecc646110..161db23ee90 100644
--- a/test/jdk/java/lang/reflect/code/TestInline.java
+++ b/test/jdk/java/lang/reflect/code/TestInline.java
@@ -50,7 +50,7 @@ public void testInline() {
Quoted q = (int a, int b) -> a + b;
CoreOps.ClosureOp cop = (CoreOps.ClosureOp) q.op();
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(fblock -> {
Block.Parameter i = fblock.parameters().get(0);
@@ -72,7 +72,7 @@ public void testInlineVar() {
Quoted q = (int a, int b) -> a + b;
CoreOps.ClosureOp cop = (CoreOps.ClosureOp) q.op();
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(fblock -> {
Block.Parameter i = fblock.parameters().get(0);
@@ -116,7 +116,7 @@ public void testInlineLowerMultipleReturn() {
});
lcop.writeTo(System.out);
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(fblock -> {
Block.Parameter i = fblock.parameters().get(0);
@@ -152,7 +152,7 @@ public void testInlineLowerMultipleReturnVar() {
});
lcop.writeTo(System.out);
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(fblock -> {
Block.Parameter i = fblock.parameters().get(0);
@@ -218,7 +218,7 @@ public void testInlineVoid() {
};
CoreOps.ClosureOp cop = (CoreOps.ClosureOp) q.op();
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(JavaType.VOID, JavaType.type(int[].class)))
.body(fblock -> {
Block.Parameter a = fblock.parameters().get(0);
diff --git a/test/jdk/java/lang/reflect/code/TestLambdaOps.java b/test/jdk/java/lang/reflect/code/TestLambdaOps.java
index 919303fcbf5..f9c4acd6212 100644
--- a/test/jdk/java/lang/reflect/code/TestLambdaOps.java
+++ b/test/jdk/java/lang/reflect/code/TestLambdaOps.java
@@ -33,7 +33,7 @@
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.op.CoreOps.FuncOp;
import java.lang.reflect.code.op.CoreOps.LambdaOp;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.interpreter.Interpreter;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
@@ -54,7 +54,7 @@
@Test
public class TestLambdaOps {
static class Builder {
- static final MethodDesc ACCEPT_METHOD = MethodDesc.method(type(Builder.class), "accept",
+ static final MethodRef ACCEPT_METHOD = MethodRef.method(type(Builder.class), "accept",
INT, CoreOps.QuotedOp.QUOTED_TYPE);
static int accept(Quoted l) {
@@ -69,13 +69,13 @@ static int accept(Quoted l) {
@Test
public void testQuotedWithCapture() {
- // functional descriptor = (int)int
+ // functional type = (int)int
FuncOp f = func("f", functionType(INT, INT))
.body(block -> {
Block.Parameter i = block.parameters().get(0);
- // functional descriptor = (int)int
- // op descriptor = ()Quoted<LambdaOp>
+ // functional type = (int)int
+ // op type = ()Quoted<LambdaOp>
QuotedOp qop = quoted(block.parentBody(), qblock -> {
return lambda(qblock.parentBody(),
functionType(INT, INT), type(IntUnaryOperator.class))
@@ -100,19 +100,19 @@ public void testQuotedWithCapture() {
Assert.assertEquals(ir, 43);
}
- static final MethodDesc INT_UNARY_OPERATOR_METHOD = MethodDesc.method(
+ static final MethodRef INT_UNARY_OPERATOR_METHOD = MethodRef.method(
IntUnaryOperator.class, "applyAsInt",
int.class, int.class);
@Test
public void testWithCapture() {
- // functional descriptor = (int)int
+ // functional type = (int)int
FuncOp f = func("f", functionType(INT, INT))
.body(block -> {
Block.Parameter i = block.parameters().get(0);
- // functional descriptor = (int)int
- // op descriptor = ()IntUnaryOperator
+ // functional type = (int)int
+ // op type = ()IntUnaryOperator
// captures i
LambdaOp lambda = lambda(block.parentBody(),
functionType(INT, INT), type(IntUnaryOperator.class))
diff --git a/test/jdk/java/lang/reflect/code/TestLinqUsingQuoted.java b/test/jdk/java/lang/reflect/code/TestLinqUsingQuoted.java
index a026026fe94..a7b1dfe1639 100644
--- a/test/jdk/java/lang/reflect/code/TestLinqUsingQuoted.java
+++ b/test/jdk/java/lang/reflect/code/TestLinqUsingQuoted.java
@@ -27,14 +27,14 @@
import java.lang.reflect.code.Op;
import java.lang.reflect.code.Quoted;
import java.lang.reflect.code.Value;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.interpreter.Interpreter;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.code.type.JavaType;
import java.lang.reflect.code.TypeElement;
import java.util.stream.Stream;
-import static java.lang.reflect.code.descriptor.MethodDesc.method;
+import static java.lang.reflect.code.type.MethodRef.method;
import static java.lang.reflect.code.op.CoreOps.*;
import static java.lang.reflect.code.type.FunctionType.functionType;
@@ -81,7 +81,7 @@ private Queryable insertQuery(TypeElement et, String name, ClosureOp c) {
Op.Result quotedLambda = block.op(quoted(block.parentBody(), qblock -> c));
- MethodDesc md = method(qp.queryableType(), name,
+ MethodRef md = method(qp.queryableType(), name,
functionType(qp.queryableType(), QuotedOp.QUOTED_TYPE));
Op.Result queryable = block.op(invoke(md, query, quotedLambda));
@@ -116,7 +116,7 @@ private QueryResult insertQueryResult(String name, TypeElement resultType) {
FuncOp nextQueryExpression = func("queryresult",
functionType(qp.queryResultType(), currentQueryExpression.invokableType().parameterTypes()))
.body(b -> b.inline(currentQueryExpression, b.parameters(), (block, query) -> {
- MethodDesc md = method(qp.queryableType(), name, functionType(qp.queryResultType()));
+ MethodRef md = method(qp.queryableType(), name, functionType(qp.queryResultType()));
Op.Result queryResult = block.op(invoke(md, query));
block.op(_return(queryResult));
@@ -159,8 +159,8 @@ public static final class TestQueryable implements Queryable {
this.provider = provider;
// Initial expression is an identity function
- var funDescriptor = functionType(provider().queryableType(), provider().queryableType());
- this.expression = func("query", funDescriptor)
+ var funType = functionType(provider().queryableType(), provider().queryableType());
+ this.expression = func("query", funType)
.body(b -> b.op(_return(b.parameters().get(0))));
}
diff --git a/test/jdk/java/lang/reflect/code/TestLocalTransformationsAdaption.java b/test/jdk/java/lang/reflect/code/TestLocalTransformationsAdaption.java
index f892b5159d8..a3d834d0f57 100644
--- a/test/jdk/java/lang/reflect/code/TestLocalTransformationsAdaption.java
+++ b/test/jdk/java/lang/reflect/code/TestLocalTransformationsAdaption.java
@@ -29,8 +29,8 @@
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.Op;
import java.lang.reflect.code.Value;
-import java.lang.reflect.code.descriptor.FieldDesc;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.FieldRef;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.interpreter.Interpreter;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
@@ -49,7 +49,7 @@
import static java.lang.reflect.code.op.CoreOps.constant;
import static java.lang.reflect.code.op.CoreOps.fieldLoad;
import static java.lang.reflect.code.op.CoreOps.newArray;
-import static java.lang.reflect.code.descriptor.MethodDesc.method;
+import static java.lang.reflect.code.type.MethodRef.method;
import static java.lang.reflect.code.type.JavaType.*;
/*
@@ -170,7 +170,7 @@ case CoreOps.ReturnOp returnOp when getNearestInvokeableAncestorOp(returnOp) ins
static void printConstantString(Function<Op, Op.Result> opBuilder, String s) {
Op.Result c = opBuilder.apply(constant(J_L_STRING, s));
- Value System_out = opBuilder.apply(fieldLoad(FieldDesc.field(System.class, "out", PrintStream.class)));
+ Value System_out = opBuilder.apply(fieldLoad(FieldRef.field(System.class, "out", PrintStream.class)));
opBuilder.apply(CoreOps.invoke(method(PrintStream.class, "println", void.class, String.class), System_out, c));
}
@@ -286,7 +286,7 @@ static void printCall(CopyContext cc, CoreOps.InvokeOp invokeOp, Function<Op, Op
Op.Result formatString = opBuilder.apply(
constant(J_L_STRING,
prefix + ": " + invokeOp.invokeDescriptor() + "(" + formatString(adaptedInvokeOperands) + ")%n"));
- Value System_out = opBuilder.apply(fieldLoad(FieldDesc.field(System.class, "out", PrintStream.class)));
+ Value System_out = opBuilder.apply(fieldLoad(FieldRef.field(System.class, "out", PrintStream.class)));
opBuilder.apply(
CoreOps.invoke(method(PrintStream.class, "printf", PrintStream.class, String.class, Object[].class),
System_out, formatString, formatArray));
@@ -328,7 +328,7 @@ static String formatString(TypeElement t) {
}
- static final MethodDesc ADD_METHOD = MethodDesc.method(
+ static final MethodRef ADD_METHOD = MethodRef.method(
TestLocalTransformationsAdaption.class, "add",
int.class, int.class, int.class);
@@ -336,7 +336,7 @@ static int add(int a, int b) {
return a + b;
}
- static final MethodDesc ADD_WITH_PRINT_METHOD = MethodDesc.method(
+ static final MethodRef ADD_WITH_PRINT_METHOD = MethodRef.method(
TestLocalTransformationsAdaption.class, "addWithPrint",
int.class, int.class, int.class);
diff --git a/test/jdk/java/lang/reflect/code/ad/ForwardDifferentiation.java b/test/jdk/java/lang/reflect/code/ad/ForwardDifferentiation.java
index 8992a524a26..4d74602aa78 100644
--- a/test/jdk/java/lang/reflect/code/ad/ForwardDifferentiation.java
+++ b/test/jdk/java/lang/reflect/code/ad/ForwardDifferentiation.java
@@ -25,7 +25,7 @@
import java.lang.reflect.code.CopyContext;
import java.lang.reflect.code.Op;
import java.lang.reflect.code.Value;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.type.FunctionType;
import java.lang.reflect.code.type.JavaType;
@@ -122,8 +122,8 @@ void processBlocks(Block.Builder block) {
static final JavaType J_L_MATH = JavaType.type(Math.class);
static final FunctionType D_D = FunctionType.functionType(DOUBLE, DOUBLE);
- static final MethodDesc J_L_MATH_SIN = MethodDesc.method(J_L_MATH, "sin", D_D);
- static final MethodDesc J_L_MATH_COS = MethodDesc.method(J_L_MATH, "cos", D_D);
+ static final MethodRef J_L_MATH_SIN = MethodRef.method(J_L_MATH, "sin", D_D);
+ static final MethodRef J_L_MATH_COS = MethodRef.method(J_L_MATH, "cos", D_D);
Value diffOp(Block.Builder block, Op op) {
// Switch on the op, using pattern matching
@@ -171,7 +171,7 @@ Value diffOp(Block.Builder block, Op op) {
yield zero;
}
case CoreOps.InvokeOp c -> {
- MethodDesc md = c.invokeDescriptor();
+ MethodRef md = c.invokeDescriptor();
String operationName = null;
if (md.refType().equals(J_L_MATH)) {
operationName = md.name();
diff --git a/test/jdk/java/lang/reflect/code/linq/Queryable.java b/test/jdk/java/lang/reflect/code/linq/Queryable.java
index b706859d8c1..732c33be316 100644
--- a/test/jdk/java/lang/reflect/code/linq/Queryable.java
+++ b/test/jdk/java/lang/reflect/code/linq/Queryable.java
@@ -22,11 +22,11 @@
*/
import java.lang.reflect.code.Op;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.type.JavaType;
import java.util.stream.Stream;
-import static java.lang.reflect.code.descriptor.MethodDesc.method;
+import static java.lang.reflect.code.type.MethodRef.method;
import static java.lang.reflect.code.op.CoreOps.*;
import static java.lang.reflect.code.type.FunctionType.functionType;
import static java.lang.reflect.code.type.JavaType.type;
@@ -63,7 +63,7 @@ private Queryable<?> insertQuery(JavaType elementType, String methodName, Lambda
.body(b -> b.inline(queryExpression, b.parameters(), (block, query) -> {
Op.Result fi = block.op(lambdaOp);
- MethodDesc md = method(Queryable.TYPE, methodName,
+ MethodRef md = method(Queryable.TYPE, methodName,
functionType(Queryable.TYPE, ((JavaType) lambdaOp.functionalInterface()).rawType()));
Op.Result queryable = block.op(invoke(queryableType, md, query, fi));
@@ -92,7 +92,7 @@ private QueryResult<?> insertQueryResult(JavaType resultType, String methodName)
FuncOp queryResultExpression = func("queryResult",
functionType(queryResultType, queryExpression.invokableType().parameterTypes()))
.body(b -> b.inline(queryExpression, b.parameters(), (block, query) -> {
- MethodDesc md = method(Queryable.TYPE, methodName,
+ MethodRef md = method(Queryable.TYPE, methodName,
functionType(QueryResult.TYPE));
Op.Result queryResult = block.op(invoke(queryResultType, md, query));
diff --git a/test/jdk/java/lang/reflect/code/linq/TestQueryProvider.java b/test/jdk/java/lang/reflect/code/linq/TestQueryProvider.java
index 79530cd17df..1a924286175 100644
--- a/test/jdk/java/lang/reflect/code/linq/TestQueryProvider.java
+++ b/test/jdk/java/lang/reflect/code/linq/TestQueryProvider.java
@@ -59,8 +59,8 @@ static final class TestQueryable<T> implements Queryable<T> {
JavaType queryableType = type(Queryable.TYPE, elementType);
// Initial expression is an identity function
- var funDescriptor = functionType(queryableType, queryableType);
- this.expression = func("query", funDescriptor)
+ var funType = functionType(queryableType, queryableType);
+ this.expression = func("query", funType)
.body(b -> b.op(_return(b.parameters().get(0))));
}
diff --git a/test/jdk/java/lang/reflect/code/parser/TestParse.java b/test/jdk/java/lang/reflect/code/parser/TestParse.java
index 9d493d6b9bf..8c04709cd47 100644
--- a/test/jdk/java/lang/reflect/code/parser/TestParse.java
+++ b/test/jdk/java/lang/reflect/code/parser/TestParse.java
@@ -33,7 +33,7 @@
import java.lang.reflect.code.Block;
import java.lang.reflect.code.op.CoreOps;
import java.lang.reflect.code.Op;
-import java.lang.reflect.code.descriptor.MethodDesc;
+import java.lang.reflect.code.type.MethodRef;
import java.lang.reflect.code.parser.OpParser;
import java.util.List;
import java.util.function.IntUnaryOperator;
@@ -49,19 +49,19 @@
public class TestParse {
- static final MethodDesc INT_UNARY_OPERATOR_METHOD = MethodDesc.method(
+ static final MethodRef INT_UNARY_OPERATOR_METHOD = MethodRef.method(
IntUnaryOperator.class, "applyAsInt",
int.class, int.class);
@Test
public void testParseLambdaOp() {
- // functional descriptor = (int)int
+ // functional type = (int)int
CoreOps.FuncOp f = func("f", functionType(INT, INT))
.body(block -> {
Block.Parameter i = block.parameters().get(0);
- // functional descriptor = (int)int
- // op descriptor = ()IntUnaryOperator
+ // functional type = (int)int
+ // op type = ()IntUnaryOperator
// captures i
CoreOps.LambdaOp lambda = lambda(block.parentBody(),
functionType(INT, INT), type(IntUnaryOperator.class))
diff --git a/test/jdk/java/lang/reflect/code/descriptors/TestDescriptors.java b/test/jdk/java/lang/reflect/code/type/TestReferences.java
similarity index 67%
rename from test/jdk/java/lang/reflect/code/descriptors/TestDescriptors.java
rename to test/jdk/java/lang/reflect/code/type/TestReferences.java
index 516af84e4c2..9c2f844ba01 100644
--- a/test/jdk/java/lang/reflect/code/descriptors/TestDescriptors.java
+++ b/test/jdk/java/lang/reflect/code/type/TestReferences.java
@@ -25,17 +25,19 @@
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
-import java.lang.reflect.code.descriptor.*;
+import java.lang.reflect.code.type.FieldRef;
+import java.lang.reflect.code.type.MethodRef;
+import java.lang.reflect.code.type.RecordTypeRef;
/*
* @test
- * @run testng TestDescriptors
+ * @run testng TestReferences
*/
-public class TestDescriptors {
+public class TestReferences {
@DataProvider
- public Object[][] methodDescriptors() {
+ public Object[][] methodRefs() {
return new Object[][]{
{"a::b()void", "a", "b"},
{"a.b::c(int)int", "a.b", "c"},
@@ -48,17 +50,17 @@ public Object[][] methodDescriptors() {
};
}
- @Test(dataProvider = "methodDescriptors")
- public void testMethodDescriptor(String mds, String refType, String name) {
- MethodDesc md = MethodDesc.ofString(mds);
- Assert.assertEquals(md.toString(), mds);
- Assert.assertEquals(md.refType().toString(), refType);
- Assert.assertEquals(md.name(), name);
+ @Test(dataProvider = "methodRefs")
+ public void testMethodRef(String mds, String refType, String name) {
+ MethodRef mr = MethodRef.ofString(mds);
+ Assert.assertEquals(mr.toString(), mds);
+ Assert.assertEquals(mr.refType().toString(), refType);
+ Assert.assertEquals(mr.name(), name);
}
@DataProvider
- public Object[][] fieldDescriptors() {
+ public Object[][] fieldRefs() {
return new Object[][]{
{"a.b::c()int", "a.b", "c", "int"},
{"a.b.c::d()int", "a.b.c", "d", "int"},
@@ -66,18 +68,18 @@ public Object[][] fieldDescriptors() {
};
}
- @Test(dataProvider = "fieldDescriptors")
- public void testFieldDescriptor(String fds, String refType, String name, String type) {
- FieldDesc fd = FieldDesc.ofString(fds);
- Assert.assertEquals(fd.toString(), fds);
- Assert.assertEquals(fd.refType().toString(), refType);
- Assert.assertEquals(fd.name(), name);
- Assert.assertEquals(fd.type().toString(), type);
+ @Test(dataProvider = "fieldRefs")
+ public void testFieldRef(String fds, String refType, String name, String type) {
+ FieldRef fr = FieldRef.ofString(fds);
+ Assert.assertEquals(fr.toString(), fds);
+ Assert.assertEquals(fr.refType().toString(), refType);
+ Assert.assertEquals(fr.name(), name);
+ Assert.assertEquals(fr.type().toString(), type);
}
@DataProvider
- public Object[][] recordTypeDescriptors() {
+ public Object[][] recordTypeRefs() {
return new Object[][]{
{"()A"},
{"(B b)A"},
@@ -86,10 +88,10 @@ public Object[][] recordTypeDescriptors() {
};
}
- @Test(dataProvider = "recordTypeDescriptors")
- public void testRecordTypeDescriptor(String rtds) {
- RecordTypeDesc mtd = RecordTypeDesc.ofString(rtds);
- Assert.assertEquals(mtd.toString(), rtds);
+ @Test(dataProvider = "recordTypeRefs")
+ public void testRecordTypeRef(String rtds) {
+ RecordTypeRef rtr = RecordTypeRef.ofString(rtds);
+ Assert.assertEquals(rtr.toString(), rtds);
}
}