JDK-8282798 java.lang.runtime.Carrier

src/java.base/share/classes/java/lang/runtime/Carriers.java

@@ -0,0 +1,1242 @@
+/*
+ * Copyright (c) 2022, 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.
+ */
+
+package java.lang.runtime;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.lang.invoke.MethodHandles.Lookup.ClassOption;
+import java.lang.invoke.MethodType;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static java.lang.invoke.MethodType.methodType;
+
+import jdk.internal.misc.Unsafe;
+import jdk.internal.misc.VM;
+import jdk.internal.org.objectweb.asm.ClassWriter;
+import jdk.internal.org.objectweb.asm.FieldVisitor;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Type;
+
+import static jdk.internal.org.objectweb.asm.Opcodes.*;
+
+/**
+ * A <em>carrier</em> is an opaque object that can be used to store component values
+ * while avoiding primitive boxing associated with collection objects. Component values
+ * can be primitive or Object.
+ * <p>
+ * Clients can create new carrier instances by describing a carrier <em>shape</em>, that
+ * is, a {@linkplain MethodType method type} whose parameter types describe the types of
+ * the carrier component values, or by providing the parameter types directly.
+ *
+ * {@snippet :
+ * // Create a carrier for a string and an integer
+ * CarrierElements elements = CarrierFactory.of(String.class, int.class);
+ * // Fetch the carrier constructor MethodHandle
+ * MethodHandle constructor = elements.constructor();
+ * // Fetch the list of carrier component MethodHandles
+ * List<MethodHandle> components = elements.components();
+ *
+ * // Create an instance of the carrier with a string and an integer
+ * Object carrier = constructor.invokeExact("abc", 10);
+ * // Extract the first component, type string
+ * String string = (String)components.get(0).invokeExact(carrier);
+ * // Extract the second component, type int
+ * int i = (int)components.get(1).invokeExact(carrier);
+ * }
+ *
+ * Alternatively, the client can use static methods when the carrier use is scattered.
+ * This is possible since {@link Carriers} ensures that the same underlying carrier
+ * class is used when the same component types are provided.
+ *
+ * {@snippet :
+ * // Describe carrier using a MethodType
+ * MethodType mt = MethodType.methodType(Object.class, String.class, int.class);
+ * // Fetch the carrier constructor MethodHandle
+ * MethodHandle constructor = Carriers.constructor(mt);
+ * // Fetch the list of carrier component MethodHandles
+ * List<MethodHandle> components = Carriers.components(mt);
+ * }
+ *
+ * @implNote The strategy for storing components is deliberately left unspecified
+ * so that future improvements will not be hampered by issues of backward compatibility.
+ *
+ * @since 19
+ */
+public final class Carriers {
+    /**
+     * Class file version.
+     */
+    private static final int CLASSFILE_VERSION = VM.classFileVersion();
+
+    /**
+     * Maximum number of components in a carrier (based on the maximum
+     * number of args to a constructor.)
+     */
+    public static final int MAX_COMPONENTS = 255 - /* this */ 1;
+
+    /**
+     * Maximum number of components in a {@link CarrierClass}.
+     */
+    private static final int MAX_OBJECT_COMPONENTS = 32;
+
+    /**
+     * Stable annotation.
+     */
+    private static final String STABLE = "jdk/internal/vm/annotation/Stable";
+    private static final String STABLE_SIG = "L" + STABLE + ";";
+
+    /**
+     * Number of integer slots used by a long.
+     */
+    private static final int LONG_SLOTS = Long.SIZE / Integer.SIZE;
+
+    /*
+     * Initialize {@link MethodHandle} constants.
+     */
+    static {
+        try {
+            Lookup lookup = MethodHandles.lookup();
+            FLOAT_TO_INT = lookup.findStatic(Float.class, "floatToRawIntBits",
+                    methodType(int.class, float.class));
+            INT_TO_FLOAT = lookup.findStatic(Float.class, "intBitsToFloat",
+                    methodType(float.class, int.class));
+            DOUBLE_TO_LONG = lookup.findStatic(Double.class, "doubleToRawLongBits",
+                    methodType(long.class, double.class));
+            LONG_TO_DOUBLE = lookup.findStatic(Double.class, "longBitsToDouble",
+                    methodType(double.class, long.class));
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError("carrier static init fail", ex);
+        }
+    }
+
+    /*
+     * float/double conversions.
+     */
+    private static final MethodHandle FLOAT_TO_INT;
+    private static final MethodHandle INT_TO_FLOAT;
+    private static final MethodHandle DOUBLE_TO_LONG;
+    private static final MethodHandle LONG_TO_DOUBLE;
+
+    /**
+     * long signature descriptor.
+     */
+    private static final String LONG_DESCRIPTOR =
+            Type.getDescriptor(long.class);
+
+    /**
+     * int signature descriptor.
+     */
+    private static final String INT_DESCRIPTOR =
+            Type.getDescriptor(int.class);
+
+    /**
+     * Object signature descriptor.
+     */
+    private static final String OBJECT_DESCRIPTOR =
+            Type.getDescriptor(Object.class);
+
+    /**
+     * Given a constructor {@link MethodHandle} recast and reorder arguments to
+     * match shape.
+     *
+     * @param carrierShape  carrier shape
+     * @param constructor   carrier constructor to reshape
+     *
+     * @return constructor with arguments recasted and reordered
+     */
+    private static MethodHandle reshapeConstructor(CarrierShape carrierShape,
+                                                   MethodHandle constructor) {
+        int count = carrierShape.count();
+        Class<?>[] ptypes = carrierShape.ptypes();
+        int objectIndex = carrierShape.objectOffset();
+        int intIndex = carrierShape.intOffset();
+        int longIndex = carrierShape.longOffset();
+        int[] reorder = new int[count];
+        Class<?>[] permutePTypes = new Class<?>[count];
+        MethodHandle[] filters = new MethodHandle[count];
+        boolean hasFilters = false;
+        int index = 0;
+
+        for (Class<?> ptype : ptypes) {
+            MethodHandle filter = null;
+            int from;
+
+            if (!ptype.isPrimitive()) {
+                from = objectIndex++;
+                ptype = Object.class;
+            } else if (ptype == double.class) {
+                from = longIndex++;
+                filter = DOUBLE_TO_LONG;
+            } else if (ptype == float.class) {
+                from = intIndex++;
+                filter = FLOAT_TO_INT;
+            } else if (ptype == long.class) {
+                from = longIndex++;
+            } else {
+                from = intIndex++;
+                ptype = int.class;
+            }
+
+            permutePTypes[index] = ptype;
+            reorder[from] = index++;
+
+            if (filter != null) {
+                filters[from] = filter;
+                hasFilters = true;
+            }
+        }
+
+        if (hasFilters) {
+            constructor = MethodHandles.filterArguments(constructor, 0, filters);
+        }
+
+        MethodType permutedMethodType =
+                methodType(constructor.type().returnType(), permutePTypes);
+        constructor = MethodHandles.permuteArguments(constructor,
+                permutedMethodType, reorder);
+        constructor = MethodHandles.explicitCastArguments(constructor,
+                methodType(Object.class, ptypes));
+
+        return constructor;
+    }
+
+    /**
+     * Given components array, recast and reorder components to match shape.
+     *
+     * @param carrierShape  carrier reshape
+     * @param components    carrier components to reshape
+     *
+     * @return list of components reshaped
+     */
+    private static List<MethodHandle> reshapeComponents(CarrierShape carrierShape,
+                                                        MethodHandle[] components) {
+        int count = carrierShape.count();
+        Class<?>[] ptypes = carrierShape.ptypes();
+        MethodHandle[] reorder = new MethodHandle[count];
+        int objectIndex = carrierShape.objectOffset();
+        int intIndex = carrierShape.intOffset();
+        int longIndex = carrierShape.longOffset();
+        int index = 0;
+
+        for (Class<?> ptype : ptypes) {
+            MethodHandle component;
+
+            if (!ptype.isPrimitive()) {
+                component = components[objectIndex++];
+            } else if (ptype == double.class) {
+                component = MethodHandles.filterReturnValue(
+                        components[longIndex++], LONG_TO_DOUBLE);
+            } else if (ptype == float.class) {
+                component = MethodHandles.filterReturnValue(
+                        components[intIndex++], INT_TO_FLOAT);
+            } else if (ptype == long.class) {
+                component = components[longIndex++];
+            } else {
+                component = components[intIndex++];
+            }
+
+            MethodType methodType = methodType(ptype, Object.class);
+            reorder[index++] =
+                    MethodHandles.explicitCastArguments(component, methodType);
+        }
+
+        return List.of(reorder);
+    }
+
+    /**
+     * Factory for carriers that are backed by int[] and Object[]. This strategy is
+     * used when the number of components exceeds {@link Carriers#MAX_OBJECT_COMPONENTS}.
+     */
+    private static class CarrierArrayFactory {
+        /**
+         * Unsafe access.
+         */
+        private static final Unsafe UNSAFE;
+
+        static {
+            try {
+                UNSAFE = Unsafe.getUnsafe();
+                Lookup lookup = MethodHandles.lookup();
+                CONSTRUCTOR = lookup.findConstructor(CarrierArray.class,
+                        methodType(void.class, int.class, int.class));
+                GET_LONG = lookup.findVirtual(CarrierArray.class, "getLong",
+                        methodType(long.class, int.class));
+                PUT_LONG = lookup.findVirtual(CarrierArray.class, "putLong",
+                        methodType(CarrierArray.class, int.class, long.class));
+                GET_INTEGER = lookup.findVirtual(CarrierArray.class, "getInteger",
+                        methodType(int.class, int.class));
+                PUT_INTEGER = lookup.findVirtual(CarrierArray.class, "putInteger",
+                        methodType(CarrierArray.class, int.class, int.class));
+                GET_OBJECT = lookup.findVirtual(CarrierArray.class, "getObject",
+                        methodType(Object.class, int.class));
+                PUT_OBJECT = lookup.findVirtual(CarrierArray.class, "putObject",
+                        methodType(CarrierArray.class, int.class, Object.class));
+            } catch (ReflectiveOperationException ex) {
+                throw new AssertionError("carrier static init fail", ex);
+            }
+        }
+
+        /*
+         * Constructor accessor MethodHandles.
+         */
+        private static final MethodHandle CONSTRUCTOR;
+        private static final MethodHandle GET_LONG;
+        private static final MethodHandle PUT_LONG;
+        private static final MethodHandle GET_INTEGER;
+        private static final MethodHandle PUT_INTEGER;
+        private static final MethodHandle GET_OBJECT;
+        private static final MethodHandle PUT_OBJECT;
+
+        /**
+         * Wrapper object for carrier arrays. Instances types are stored in the {@code objects}
+         * array, while primitive types are recast to {@code int/long} and stored in the
+         * {@code primitives} array. Primitive byte, short, char, boolean and int are stored as
+         * integers. Longs and doubles are stored as longs.  Longs take up the first part of the
+         * primitives array using normal indices. Integers follow using int[] indices offset beyond
+         * the longs using unsafe getInt/putInt.
+         */
+        private static class CarrierArray {
+            /**
+             * Carrier for primitive values.
+             */
+            private final long[] primitives;
+
+            /**
+             * Carrier for objects;
+             */
+            private final Object[] objects;
+
+            /**
+             * Constructor.
+             *
+             * @param primitiveCount  slot count required for primitives
+             * @param objectCount     slot count required for objects
+             */
+            CarrierArray(int primitiveCount, int objectCount) {
+                this.primitives =
+                        primitiveCount != 0 ? new long[(primitiveCount + 1) / LONG_SLOTS] : null;
+                this.objects = objectCount != 0 ? new Object[objectCount] : null;
+            }
+
+            /**
+             * Check index and compute offset for unsafe access.
+             *
+             * @param i  index in primitive[]
+             *
+             * @return offset for unsafe access
+             */
+            private long offset(int i) {
+                if (i < 0 || (primitives.length * LONG_SLOTS) <= i) {
+                    throw new RuntimeException("primitive index out of range: " + i);
+                }
+
+                return Unsafe.ARRAY_LONG_BASE_OFFSET +
+                        (long)i * Unsafe.ARRAY_INT_INDEX_SCALE;
+            }
+
+            /**
+             * {@return long value at index}
+             *
+             * @param i  array index
+             */
+            private long getLong(int i) {
+                return primitives[i];
+            }
+
+            /**
+             * Put a long value into the primitive[].
+             *
+             * @param i      array index
+             * @param value  long value to store
+             *
+             * @return this object
+             */
+            private CarrierArray putLong(int i, long value) {
+                primitives[i] = value;
+
+                return this;
+            }
+
+            /**
+             * {@return int value at index}
+             *
+             * @param i  array index
+             */
+            private int getInteger(int i) {
+                return UNSAFE.getInt(primitives, offset(i));
+            }
+
+            /**
+             * Put a int value into the int[].
+             *
+             * @param i      array index
+             * @param value  int value to store
+             *
+             * @return this object
+             */
+            private CarrierArray putInteger(int i, int value) {
+                UNSAFE.putInt(primitives, offset(i), value);
+
+                return this;
+            }
+
+            /**
+             * {@return Object value at index}
+             *
+             * @param i  array index
+             */
+            private Object getObject(int i) {
+                return objects[i];
+            }
+
+            /**
+             * Put a object value into the objects[].
+             *
+             * @param i      array index
+             * @param value  object value to store
+             *
+             * @return this object
+             */
+            private CarrierArray putObject(int i, Object value) {
+                objects[i] = value;
+
+                return this;
+            }
+        }
+
+        /**
+         * Constructor
+         *
+         * @param carrierShape  carrier object shape
+         *
+         * @return {@link MethodHandle} to generic carrier constructor.
+         */
+        private static MethodHandle constructor(CarrierShape carrierShape) {
+            int longCount = carrierShape.longCount();
+            int intCount = carrierShape.intCount();
+            int objectCount = carrierShape.objectCount();
+            int primitiveCount = longCount * LONG_SLOTS + intCount;
+
+            MethodHandle constructor = MethodHandles.insertArguments(CONSTRUCTOR,
+                    0, primitiveCount, objectCount);
+
+            // long array index
+            int index = 0;
+            for (int i = 0; i < longCount; i++) {
+                MethodHandle put = MethodHandles.insertArguments(PUT_LONG, 1, index++);
+                constructor = MethodHandles.collectArguments(put, 0, constructor);
+            }
+
+            // transition to int array index (double number of longs)
+            index *= LONG_SLOTS;
+            for (int i = 0; i < intCount; i++) {
+                MethodHandle put = MethodHandles.insertArguments(PUT_INTEGER, 1, index++);
+                constructor = MethodHandles.collectArguments(put, 0, constructor);
+            }
+
+            for (int i = 0; i < objectCount; i++) {
+                MethodHandle put = MethodHandles.insertArguments(PUT_OBJECT, 1, i);
+                constructor = MethodHandles.collectArguments(put, 0, constructor);
+            }
+
+            return constructor;
+        }
+
+        /**
+         * Utility to construct the basic accessors from the components.
+         *
+         * @param carrierShape  carrier object shape
+         *
+         * @return array of carrier accessors
+         */
+        private static MethodHandle[] createComponents(CarrierShape carrierShape) {
+            int longCount = carrierShape.longCount();
+            int intCount = carrierShape.intCount();
+            int objectCount = carrierShape.objectCount();
+            MethodHandle[] components =
+                    new MethodHandle[carrierShape.ptypes().length];
+
+            // long array index
+            int index = 0;
+            // component index
+            int comIndex = 0;
+            for (int i = 0; i < longCount; i++) {
+                components[comIndex++] = MethodHandles.insertArguments(GET_LONG, 1, index++);
+            }
+
+            // transition to int array index (double number of longs)
+            index *= LONG_SLOTS;
+            for (int i = 0; i < intCount; i++) {
+                components[comIndex++] = MethodHandles.insertArguments(GET_INTEGER, 1, index++);
+            }
+
+            for (int i = 0; i < objectCount; i++) {
+                components[comIndex++] = MethodHandles.insertArguments(GET_OBJECT, 1, i);
+            }
+            return components;
+        }
+
+        /**
+         * Permute a raw constructor and component accessor {@link MethodHandle MethodHandles} to
+         * match the order and types of the parameter types.
+         *
+         * @param carrierShape  carrier object shape
+         *
+         * @return {@link CarrierElements} instance
+         */
+        private static CarrierElements carrier(CarrierShape carrierShape) {
+            MethodHandle constructor = constructor(carrierShape);
+            MethodHandle[] components = createComponents(carrierShape);
+
+            return new CarrierElements(Object[].class,
+                                       reshapeConstructor(carrierShape, constructor),
+                                       reshapeComponents(carrierShape, components));
+        }
+    }
+
+    /**
+     * Factory for object based carrier. This strategy is used when the number of
+     * components is less than equal {@link Carriers#MAX_OBJECT_COMPONENTS}. The factory
+     * constructs an anonymous class that provides a shape that  matches the
+     * number of longs, ints and objects required by the {@link CarrierShape}. The
+     * factory caches and reuses anonymous classes when looking for a match.
+     * <p>
+     * The anonymous class that is constructed contains the number of long fields then
+     * int fields then object fields required by the {@link CarrierShape}. The order
+     * of fields is reordered by the component accessor {@link MethodHandles}. So a
+     * carrier requiring an int and then object will use the same anonymous class as
+     * a carrier requiring an object then int.
+     * <p>
+     * The carrier constructor recasts/translates values that are not long, int or
+     * object. The component accessors reverse the effect of the recasts/translates.
+     */
+    private static class CarrierObjectFactory {
+        /**
+         * Define the hidden class Lookup object
+         *
+         * @param bytes  class content
+         *
+         * @return the Lookup object of the hidden class
+         */
+        private static Lookup defineHiddenClass(byte[] bytes) {
+            try {
+                Lookup lookup = MethodHandles.lookup();
+                return lookup.defineHiddenClass(bytes, false, ClassOption.STRONG);
+            } catch (IllegalAccessException ex) {
+                throw new AssertionError("carrier factory static init fail", ex);
+            }
+        }
+
+        /**
+         * Generate the name of a long component.
+         *
+         * @param index field/component index
+         *
+         * @return name of long component
+         */
+        private static String longFieldName(int index) {
+            return "l" + index;
+        }
+
+        /**
+         * Generate the name of an int component.
+         *
+         * @param index field/component index
+         *
+         * @return name of int component
+         */
+        private static String intFieldName(int index) {
+            return "i" + index;
+        }
+
+        /**
+         * Generate the name of an object component.
+         *
+         * @param index field/component index
+         *
+         * @return name of object component
+         */
+        private static String objectFieldName(int index) {
+            return "o" + index;
+        }
+
+        /**
+         * Generate the full name of a carrier class based on shape.
+         *
+         * @param carrierShape  shape of carrier
+         *
+         * @return name of a carrier class
+         */
+        private static String carrierClassName(CarrierShape carrierShape) {
+            String packageName = Carriers.class.getPackageName().replace('.', '/');
+            String className = "Carrier" +
+                    longFieldName(carrierShape.longCount()) +
+                    intFieldName(carrierShape.intCount()) +
+                    objectFieldName(carrierShape.objectCount());
+
+            return packageName.isEmpty() ? className :
+                    packageName + "/" + className;
+        }
+
+        /**
+         * Build up the byte code for the carrier class.
+         *
+         * @param carrierShape  shape of carrier
+         *
+         * @return byte array of byte code for the carrier class
+         */
+        private static byte[] buildCarrierClass(CarrierShape carrierShape) {
+            int maxStack = 3;
+            int maxLocals = 1 /* this */ + carrierShape.slotCount();
+            String carrierClassName = carrierClassName(carrierShape);
+            StringBuilder initDescriptor = new StringBuilder("(");
+
+            ClassWriter cw = new ClassWriter(0);
+            cw.visit(CLASSFILE_VERSION, ACC_PRIVATE | ACC_FINAL, carrierClassName,
+                    null, "java/lang/Object", null);
+
+            int fieldFlags = ACC_PRIVATE | ACC_FINAL;
+
+            for (int i = 0; i < carrierShape.longCount(); i++) {
+                FieldVisitor fw = cw.visitField(fieldFlags, longFieldName(i),
+                        LONG_DESCRIPTOR, null, null);
+                fw.visitAnnotation(STABLE_SIG, true);
+                fw.visitEnd();
+                initDescriptor.append(LONG_DESCRIPTOR);
+            }
+
+            for (int i = 0; i < carrierShape.intCount(); i++) {
+                FieldVisitor fw = cw.visitField(fieldFlags, intFieldName(i),
+                        INT_DESCRIPTOR, null, null);
+                fw.visitAnnotation(STABLE_SIG, true);
+                fw.visitEnd();
+                initDescriptor.append(INT_DESCRIPTOR);
+            }
+
+            for (int i = 0; i < carrierShape.objectCount(); i++) {
+                FieldVisitor fw = cw.visitField(fieldFlags, objectFieldName(i),
+                        OBJECT_DESCRIPTOR, null, null);
+                fw.visitAnnotation(STABLE_SIG, true);
+                fw.visitEnd();
+                initDescriptor.append(OBJECT_DESCRIPTOR);
+            }
+
+            initDescriptor.append(")V");
+
+            int arg = 1;
+
+            MethodVisitor init = cw.visitMethod(ACC_PUBLIC,
+                    "<init>", initDescriptor.toString(), null, null);
+            init.visitVarInsn(ALOAD, 0);
+            init.visitMethodInsn(INVOKESPECIAL,
+                    "java/lang/Object", "<init>", "()V", false);
+
+            for (int i = 0; i < carrierShape.longCount(); i++) {
+                init.visitVarInsn(ALOAD, 0);
+                init.visitVarInsn(LLOAD, arg);
+                arg += LONG_SLOTS;
+                init.visitFieldInsn(PUTFIELD, carrierClassName,
+                        longFieldName(i), LONG_DESCRIPTOR);
+            }
+
+            for (int i = 0; i < carrierShape.intCount(); i++) {
+                init.visitVarInsn(ALOAD, 0);
+                init.visitVarInsn(ILOAD, arg++);
+                init.visitFieldInsn(PUTFIELD, carrierClassName,
+                        intFieldName(i), INT_DESCRIPTOR);
+            }
+
+            for (int i = 0; i < carrierShape.objectCount(); i++) {
+                init.visitVarInsn(ALOAD, 0);
+                init.visitVarInsn(ALOAD, arg++);
+                init.visitFieldInsn(PUTFIELD, carrierClassName,
+                        objectFieldName(i), OBJECT_DESCRIPTOR);
+            }
+
+            init.visitInsn(RETURN);
+            init.visitMaxs(maxStack, maxLocals);
+            init.visitEnd();
+
+            cw.visitEnd();
+
+            return cw.toByteArray();
+        }
+
+        /**
+         * Build up a {@link MethodType} based in a carrier shape.
+         *
+         * @param carrierShape  shape of carrier
+         *
+         * @return the constructor method type
+         */
+        private static MethodType constructorMethodType(CarrierShape carrierShape) {
+            int longCount = carrierShape.longCount();
+            int intCount = carrierShape.intCount();
+            int objectCount = carrierShape.objectCount();
+            int count = carrierShape.count();
+            Class<?>[] ptypes = new Class<?>[count];
+            int arg = 0;
+
+            for(int i = 0; i < longCount; i++) {
+                ptypes[arg++] = long.class;
+            }
+
+            for(int i = 0; i < intCount; i++) {
+                ptypes[arg++] = int.class;
+            }
+
+            for(int i = 0; i < objectCount; i++) {
+                ptypes[arg++] = Object.class;
+            }
+
+            return methodType(void.class, ptypes);
+        }
+
+        /**
+         * Returns the raw constructor for the carrier class.
+         *
+         * @param carrierClassLookup     lookup for carrier class
+         * @param carrierClass           newly constructed carrier class
+         * @param constructorMethodType  constructor method type
+         *
+         * @return {@link MethodHandle} to carrier class constructor
+         *
+         * @throws ReflectiveOperationException if lookup failure
+         */
+        private static MethodHandle constructor(Lookup carrierClassLookup,
+                                                Class<?> carrierClass,
+                                                MethodType constructorMethodType)
+                throws ReflectiveOperationException {
+            return carrierClassLookup.findConstructor(carrierClass,
+                    constructorMethodType);
+        }
+
+        /**
+         * Returns an array of raw component accessors for the carrier class.
+         *
+         * @param carrierShape           shape of carrier
+         * @param carrierClassLookup     lookup for carrier class
+         * @param carrierClass           newly constructed carrier class
+         *
+         * @return {@link MethodHandle MethodHandles} to carrier component
+         *         accessors
+         *
+         * @throws ReflectiveOperationException if lookup failure
+         */
+        private static MethodHandle[] createComponents(CarrierShape carrierShape,
+                                                       Lookup carrierClassLookup,
+                                                       Class<?> carrierClass)
+                throws ReflectiveOperationException {
+            int longCount = carrierShape.longCount();
+            int intCount = carrierShape.intCount();
+            int objectCount = carrierShape.objectCount();
+            int count = carrierShape.count();
+            MethodHandle[] components = new MethodHandle[count];
+            int arg = 0;
+
+            for(int i = 0; i < longCount; i++) {
+                components[arg++] = carrierClassLookup.findGetter(carrierClass,
+                        longFieldName(i), long.class);
+            }
+
+            for(int i = 0; i < intCount; i++) {
+                components[arg++] = carrierClassLookup.findGetter(carrierClass,
+                        intFieldName(i), int.class);
+            }
+
+            for(int i = 0; i < objectCount; i++) {
+                components[arg++] = carrierClassLookup.findGetter(carrierClass,
+                        objectFieldName(i), Object.class);
+            }
+
+            return components;
+        }
+
+        /**
+         * Construct a new object carrier class based on shape.
+         *
+         * @param carrierShape  shape of carrier
+         *
+         * @return a {@link CarrierClass} object containing constructor and
+         *         component accessors.
+         */
+        private static CarrierClass newCarrierClass(CarrierShape carrierShape) {
+            byte[] bytes = buildCarrierClass(carrierShape);
+
+            try {
+                Lookup carrierCLassLookup = defineHiddenClass(bytes);
+                Class<?> carrierClass = carrierCLassLookup.lookupClass();
+                MethodType constructorMethodType = constructorMethodType(carrierShape);
+                MethodHandle constructor = constructor(carrierCLassLookup,
+                        carrierClass, constructorMethodType);
+                MethodHandle[] components = createComponents(carrierShape,
+                        carrierCLassLookup, carrierClass);
+
+                return new CarrierClass(constructor, components);
+            } catch (ReflectiveOperationException ex) {
+                throw new AssertionError("carrier class static init fail", ex);
+            }
+        }
+
+        /**
+         * Permute a raw constructor and component accessor
+         * {@link MethodHandle MethodHandles} to match the order and types of
+         * the parameter types.
+         *
+         * @param carrierShape  carrier object shape
+         *
+         * @return {@link CarrierElements} instance
+         */
+        private static CarrierElements carrier(CarrierShape carrierShape) {
+            CarrierClass carrierClass = findCarrierClass(carrierShape);
+            MethodHandle constructor = carrierClass.constructor();
+            MethodHandle[] components = carrierClass.components();
+
+            return new CarrierElements(constructor.type().returnType(),
+                                       reshapeConstructor(carrierShape, constructor),
+                                       reshapeComponents(carrierShape, components));
+        }
+    }
+
+    /**
+     * Provides raw constructor and component MethodHandles for a constructed
+     * carrier class.
+     */
+    private record CarrierClass(
+            /*
+             * A raw {@link MethodHandle} for a carrier object constructor.
+             * This constructor will only have Object, int and long type arguments.
+             */
+            MethodHandle constructor,
+
+            /*
+             * All the raw {@link MethodHandle MethodHandles} for a carrier
+             * component accessors. These accessors will only return Object, int and
+             * long types.
+             */
+            MethodHandle[] components) {
+    }
+
+    /**
+     * Cache for all constructed carrier object classes, keyed on class
+     * name (i.e., carrier shape.)
+     */
+    private static final ConcurrentHashMap<String, CarrierClass> carrierCache =
+            new ConcurrentHashMap<>();
+
+    /**
+     * Constructor
+     */
+    private Carriers() {
+        throw new AssertionError("private constructor");
+    }
+
+    /**
+     * Find or create carrier class for a carrier shape.
+     *
+     * @param carrierShape  shape of carrier
+     *
+     * @return {@link Class<>} of carrier class matching carrier shape
+     */
+    private static CarrierClass findCarrierClass(CarrierShape carrierShape) {
+        String carrierClassName =
+                CarrierObjectFactory.carrierClassName(carrierShape);
+
+        return carrierCache.computeIfAbsent(carrierClassName,
+                cn -> CarrierObjectFactory.newCarrierClass(carrierShape));
+    }
+
+    private record CarrierCounts(int longCount, int intCount, int objectCount) {
+        /**
+         * Count the number of fields required in each of Object, int and long.
+         *
+         * @param ptypes  parameter types
+         *
+         * @return a {@link CarrierCounts} instance containing counts
+         */
+        static CarrierCounts tally(Class<?>[] ptypes) {
+            return tally(ptypes, ptypes.length);
+        }
+
+        /**
+         * Count the number of fields required in each of Object, int and long
+         * limited to the first {@code n} parameters.
+         *
+         * @param ptypes  parameter types
+         * @param n       number of parameters to check
+         *
+         * @return a {@link CarrierCounts} instance containing counts
+         */
+        private static CarrierCounts tally(Class<?>[] ptypes, int n) {
+            int longCount = 0;
+            int intCount = 0;
+            int objectCount = 0;
+
+            for (int i = 0; i < n; i++) {
+                Class<?> ptype = ptypes[i];
+
+                if (!ptype.isPrimitive()) {
+                    objectCount++;
+                } else if (ptype == long.class || ptype == double.class) {
+                    longCount++;
+                } else {
+                    intCount++;
+                }
+            }
+
+            return new CarrierCounts(longCount, intCount, objectCount);
+        }
+
+        /**
+         * {@return total number of components}
+         */
+        private int count() {
+            return longCount + intCount + objectCount;
+        }
+
+        /**
+         * {@return total number of slots}
+         */
+        private int slotCount() {
+            return longCount * LONG_SLOTS + intCount + objectCount;
+        }
+
+    }
+
+    /**
+     * Shape of carrier based on counts of each of the three fundamental data
+     * types.
+     */
+    private static class CarrierShape {
+        /**
+         * {@link MethodType} providing types for the carrier's components.
+         */
+        private final MethodType methodType;
+
+        /**
+         * Counts of different parameter types.
+         */
+        private final CarrierCounts counts;
+
+        /**
+         * Constructor.
+         *
+         * @param methodType  {@link MethodType} providing types for the
+         *                    carrier's components
+         */
+        public CarrierShape(MethodType methodType) {
+            this.methodType = methodType;
+            this.counts = CarrierCounts.tally(methodType.parameterArray());
+        }
+
+        /**
+         * {@return number of long fields needed}
+         */
+        private int longCount() {
+            return counts.longCount();
+        }
+
+        /**
+         * {@return number of int fields needed}
+         */
+        private int intCount() {
+            return counts.intCount();
+        }
+
+        /**
+         * {@return number of object fields needed}
+         */
+        private int objectCount() {
+            return counts.objectCount();
+        }
+
+        /**
+         * {@return array of parameter types}
+         */
+        private Class<?>[] ptypes() {
+            return methodType.parameterArray();
+        }
+
+        /**
+         * {@return number of components}
+         */
+        private int count() {
+            return counts.count();
+        }
+
+        /**
+         * {@return number of slots used}
+         */
+        private int slotCount() {
+            return counts.slotCount();
+        }
+
+        /**
+         * {@return index of first long component}
+         */
+        private int longOffset() {
+            return 0;
+        }
+
+        /**
+         * {@return index of first int component}
+         */
+        private int intOffset() {
+            return longCount();
+        }
+
+        /**
+         * {@return index of first object component}
+         */
+        private int objectOffset() {
+            return longCount() + intCount();
+        }
+
+        /**
+         * {@return true if primitive components present}
+         */
+        private boolean hasPrimitives() {
+            return longCount() != 0 ||  intCount() != 0;
+        }
+    }
+
+    /**
+     * This factory class generates {@link CarrierElements} instances containing the
+     * {@link MethodHandle MethodHandles} to the constructor and accessors of a carrier
+     * object.
+     * <p>
+     * Clients can create instances by describing a carrier <em>shape</em>, that
+     * is, a {@linkplain MethodType method type} whose parameter types describe the types of
+     * the carrier component values, or by providing the parameter types directly.
+     */
+    public static class CarrierFactory {
+        /**
+         * Constructor
+         */
+        private CarrierFactory() {
+            throw new AssertionError("private constructor");
+        }
+
+        /**
+         * Cache mapping {@link MethodType} to previously defined {@link CarrierElements}.
+         */
+        private static ConcurrentHashMap<MethodType, CarrierElements>
+                methodTypeCache = new ConcurrentHashMap<>();
+
+        /**
+         * Factory method to return a {@link CarrierElements} instance that matches the shape of
+         * the supplied {@link MethodType}. The return type of the {@link MethodType} is ignored.
+         *
+         * @param methodType  {@link MethodType} whose parameter types supply the
+         *                    the shape of the carrier's components
+         *
+         * @return {@link CarrierElements} instance
+         *
+         * @throws NullPointerException is methodType is null
+         * @throws IllegalArgumentException if number of component slots exceeds maximum
+         */
+        public static CarrierElements of(MethodType methodType) {
+            Objects.requireNonNull(methodType, "methodType must be not be null");
+            MethodType constructorMT = methodType.changeReturnType(Object.class);
+            CarrierShape carrierShape = new CarrierShape(constructorMT);
+            int slotCount = carrierShape.slotCount();
+
+            if (MAX_COMPONENTS < slotCount) {
+                throw new IllegalArgumentException("Exceeds maximum number of component slots");
+            }
+
+            return methodTypeCache.computeIfAbsent(constructorMT, (mt) -> {
+                if (slotCount <= MAX_OBJECT_COMPONENTS && carrierShape.hasPrimitives()) {
+                    return CarrierObjectFactory.carrier(carrierShape);
+                } else {
+                    return CarrierArrayFactory.carrier(carrierShape);
+                }
+            });
+        }
+
+        /**
+         * Factory method to return  a {@link CarrierElements} instance that matches the shape of
+         * the supplied parameter types.
+         *
+         * @param ptypes   parameter types that supply the shape of the carrier's components
+         *
+         * @return {@link CarrierElements} instance
+         *
+         * @throws NullPointerException is ptypes is null
+         * @throws IllegalArgumentException if number of component slots exceeds maximum
+         */
+        public static CarrierElements of(Class < ? >...ptypes) {
+            Objects.requireNonNull(ptypes, "ptypes must be not be null");
+            return of(methodType(Object.class, ptypes));
+        }
+    }
+
+    /**
+     * Instances of this class provide the {@link MethodHandle MethodHandles} to the
+     * constructor and accessors of a carrier object. The original component types can be
+     * gleaned from the parameter types of the constructor {@link MethodHandle} or by the
+     * return types of the components' {@link MethodHandle MethodHandles}.
+     */
+    public static class CarrierElements {
+        /**
+         * Underlying carrier class.
+         */
+        private final Class<?> carrierClass;
+
+        /**
+         * Constructor {@link MethodHandle}.
+         */
+        private final MethodHandle constructor;
+
+        /**
+         * List of component {@link MethodHandle MethodHandles}
+         */
+        private final List<MethodHandle> components;
+
+        /**
+         * Constructor
+         */
+        private CarrierElements() {
+            throw new AssertionError("private constructor");
+        }
+
+        /**
+         * Constructor
+         */
+        private CarrierElements(Class<?> carrierClass,
+                                MethodHandle constructor,
+                                List<MethodHandle> components) {
+            this.carrierClass = carrierClass;
+            this.constructor = constructor;
+            this.components = components;
+        }
+
+        /**
+         * {@return the underlying carrier class}
+         */
+        public Class<?> carrierClass() {
+            return carrierClass;
+        }
+
+        /**
+         * {@return the constructor {@link MethodHandle} for the carrier. The
+         * carrier constructor will always have a return type of {@link Object} }
+         */
+        public MethodHandle constructor() {
+            return constructor;
+        }
+
+        /**
+         * {@return immutable list of component accessor {@link MethodHandle MethodHandles}
+         * for all the carrier's components. The receiver type of the accessors
+         * will always be {@link Object} }
+         */
+        public List<MethodHandle> components() {
+            return components;
+        }
+
+        /**
+         * {@return a component accessor {@link MethodHandle} for component {@code i}.
+         * The receiver type of the accessor will be {@link Object} }
+         *
+         * @param i  component index
+         *
+         * @throws IllegalArgumentException if {@code i} is out of bounds
+         */
+        public MethodHandle component(int i) {
+            if (i < 0 || components.size() <= i) {
+                throw new IllegalArgumentException("i is out of bounds " + i +
+                        " of " + components.size());
+            }
+
+            return components.get(i);
+        }
+
+        @Override
+        public String toString() {
+            return "Carrier" + constructor.type().parameterList();
+        }
+    }
+
+    /**
+     * {@return the underlying carrier class of the carrier representing {@code methodType} }
+     *
+     * @param methodType  {@link MethodType} whose parameter types supply the the shape of the
+     *                    carrier's components
+     *
+     * @implNote Used internally by Condy APIs.
+     */
+    public static Class<?> carrierClass(MethodType methodType) {
+        return CarrierFactory.of(methodType).carrierClass();
+    }
+
+    /**
+     * {@return the constructor {@link MethodHandle} for the carrier representing {@code
+     * methodType}. The carrier constructor will always have a return type of {@link Object} }
+     *
+     * @param methodType  {@link MethodType} whose parameter types supply the the shape of the
+     *                    carrier's components
+     *
+     * @implNote Used internally by Condy APIs.
+     */
+    public static MethodHandle constructor(MethodType methodType) {
+        return CarrierFactory.of(methodType).constructor();
+    }
+
+    /**
+     * {@return immutable list of component accessor {@link MethodHandle MethodHandles} for
+     * all the components of the carrier representing {@code methodType}. The receiver type of
+     * the accessors will always be {@link Object} }
+     *
+     * @param methodType  {@link MethodType} whose parameter types supply the the shape of the
+     *                    carrier's components
+     *
+     * @implNote Used internally by Condy APIs.
+     */
+    public static List<MethodHandle> components(MethodType methodType) {
+        return CarrierFactory.of(methodType).components();
+    }
+
+    /**
+     * {@return a component accessor {@link MethodHandle} for component {@code i} of the
+     * carrier representing {@code methodType}. The receiver type of the accessor will always
+     * be {@link Object} }
+     *
+     * @param methodType  {@link MethodType} whose parameter types supply the the shape of the
+     *                    carrier's components
+     * @param i           component index
+     *
+     * @implNote Used internally by Condy APIs.
+     *
+     * @throws IllegalArgumentException if {@code i} is out of bounds
+     */
+    public static MethodHandle component(MethodType methodType, int i) {
+        return CarrierFactory.of(methodType).component(i);
+    }
+}

test/jdk/java/lang/runtime/CarrierTest.java

@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2022, 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.
+ *
+ * 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.
+ */
+
+/*
+ * @test
+ * @summary Test features provided by the Carrier class.
+ * @compile CarrierTest.java
+ * @run main CarrierTest
+ */
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.lang.runtime.Carriers;
+import java.lang.runtime.Carriers.*;
+import java.util.Arrays;
+
+public class CarrierTest {
+    public static void main(String[] args) throws Throwable {
+        primitivesTest();
+        primitivesTestInArrayCarrier();
+        limitsTest();
+        cacheTest();
+        staticTest();
+    }
+
+    static void assertTrue(boolean test, String message) {
+        if (!test) {
+            throw new RuntimeException(message);
+        }
+    }
+
+    static void primitivesTest() throws Throwable {
+        MethodType methodType =
+                MethodType.methodType(Object.class, byte.class, short.class,
+                        char.class, int.class, long.class,
+                        float.class, double.class,
+                        boolean.class, String.class);
+        CarrierElements carrier = Carriers.CarrierFactory.of(methodType);
+        Class<?> carrierClass = carrier.carrierClass();
+        assertTrue(!carrierClass.isArray(), "carrier should be instance");
+        MethodHandle constructor = carrier.constructor();
+        Object object = (Object)constructor.invokeExact((byte)0xFF, (short)0xFFFF,
+                'C', 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFFL,
+                1.0f / 3.0f, 1.0 / 3.0,
+                true, "abcde");
+        MethodHandle[] components = carrier.components().toArray(new MethodHandle[0]);
+
+        assertTrue((byte)components[0].invokeExact(object) == (byte)0xFF,
+                "primitive byte test failure");
+        assertTrue((short)components[1].invokeExact(object) == (short)0xFFFF,
+                "primitive short test failure");
+        assertTrue((char)components[2].invokeExact(object) == 'C',
+                "primitive char test failure");
+        assertTrue((int)components[3].invokeExact(object) == 0xFFFFFFFF,
+                "primitive int test failure");
+        assertTrue((long)components[4].invokeExact(object) == 0xFFFFFFFFFFFFFFFFL,
+                "primitive long test failure");
+        assertTrue((float)components[5].invokeExact(object) == 1.0f / 3.0f,
+                "primitive float test failure");
+        assertTrue((double)components[6].invokeExact(object) == 1.0 / 3.0,
+                "primitive double test failure");
+        assertTrue((boolean)components[7].invokeExact(object),
+                "primitive boolean test failure");
+        assertTrue("abcde".equals((String)components[8].invokeExact(object)),
+                "primitive String test failure");
+
+        MethodHandle component = carrier.component(8);
+        assertTrue("abcde".equals((String)component.invokeExact(object)),
+                "primitive String test failure");
+    }
+
+    static void primitivesTestInArrayCarrier() throws Throwable {
+        MethodType methodType =
+                MethodType.methodType(Object.class, byte.class, short.class,
+                        char.class, int.class, long.class,
+                        float.class, double.class,
+                        boolean.class, String.class,
+                        Object.class, Object.class,Object.class,Object.class,
+                        Object.class, Object.class,Object.class,Object.class,
+                        Object.class, Object.class,Object.class,Object.class,
+                        Object.class, Object.class,Object.class,Object.class,
+                        Object.class, Object.class,Object.class,Object.class,
+                        Object.class, Object.class,Object.class,Object.class,
+                        Object.class, Object.class,Object.class,Object.class
+                );
+        CarrierElements carrier = Carriers.CarrierFactory.of(methodType);
+        Class<?> carrierClass = carrier.carrierClass();
+        assertTrue(carrierClass.isArray(), "carrier should be array");
+        MethodHandle constructor = carrier.constructor();
+        Object object = (Object)constructor.invokeExact((byte)0xFF, (short)0xFFFF,
+                'C', 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFFL,
+                1.0f / 3.0f, 1.0 / 3.0,
+                true, "abcde",
+                (Object)null, (Object)null, (Object)null, (Object)null,
+                (Object)null, (Object)null, (Object)null, (Object)null,
+                (Object)null, (Object)null, (Object)null, (Object)null,
+                (Object)null, (Object)null, (Object)null, (Object)null,
+                (Object)null, (Object)null, (Object)null, (Object)null,
+                (Object)null, (Object)null, (Object)null, (Object)null,
+                (Object)null, (Object)null, (Object)null, (Object)null
+        );
+        MethodHandle[] components = carrier.components().toArray(new MethodHandle[0]);
+        assertTrue((byte)components[0].invokeExact(object) == (byte)0xFF,
+                "primitive in array byte test failure");
+        assertTrue((short)components[1].invokeExact(object) == (short)0xFFFF,
+                "primitive in array short test failure");
+        assertTrue((char)components[2].invokeExact(object) == 'C',
+                "primitive in array char test failure");
+        assertTrue((int)components[3].invokeExact(object) == 0xFFFFFFFF,
+                "primitive in array int test failure");
+        assertTrue((long)components[4].invokeExact(object) == 0xFFFFFFFFFFFFFFFFL,
+                "primitive in array long test failure");
+        assertTrue((float)components[5].invokeExact(object) == 1.0f / 3.0f,
+                "primitive in array float test failure");
+        assertTrue((double)components[6].invokeExact(object) == 1.0 / 3.0,
+                "primitive in array double test failure");
+        assertTrue((boolean)components[7].invokeExact(object),
+                "primitive in array boolean test failure");
+        assertTrue("abcde".equals((String)components[8].invokeExact(object)),
+                "primitive in array String test failure");
+    }
+
+    static void limitsTest() {
+        boolean passed;
+
+        passed = false;
+        try {
+            Class<?>[] ptypes = new Class<?>[Carriers.MAX_COMPONENTS + 1];
+            Arrays.fill(ptypes, Object.class);
+            MethodType methodType = MethodType.methodType(Object.class, ptypes);
+            CarrierElements carrier = Carriers.CarrierFactory.of(methodType);
+            MethodHandle constructor = carrier.constructor();
+        } catch (IllegalArgumentException ex) {
+            passed = true;
+        }
+
+        assertTrue(passed, "failed to report too many components");
+
+        passed = false;
+        try {
+            Class<?>[] ptypes = new Class<?>[Carriers.MAX_COMPONENTS / 2 + 1];
+            Arrays.fill(ptypes, long.class);
+            MethodType methodType = MethodType.methodType(Object.class, ptypes);
+            CarrierElements carrier = Carriers.CarrierFactory.of(methodType);
+            MethodHandle constructor = carrier.constructor();
+        } catch (IllegalArgumentException ex) {
+            passed = true;
+        }
+
+        assertTrue(passed, "failed to report too many components");
+    }
+
+    static void cacheTest() {
+        Class<?>[] ptypes = new Class<?>[] {
+                byte.class, short.class,
+                char.class, int.class, long.class,
+                float.class, double.class,
+                boolean.class, String.class
+        };
+        MethodType methodType = MethodType.methodType(Object.class, ptypes);
+        CarrierElements carrier1 = Carriers.CarrierFactory.of(ptypes);
+        CarrierElements carrier2 = Carriers.CarrierFactory.of(methodType);
+
+        assertTrue(carrier1 == carrier2, "carrier cache not matching correctly");
+    }
+
+    static void staticTest() {
+        Class<?>[] ptypes = new Class<?>[] {
+                byte.class, short.class,
+                char.class, int.class, long.class,
+                float.class, double.class,
+                boolean.class, String.class
+        };
+        MethodType methodType = MethodType.methodType(Object.class, ptypes);
+        CarrierElements carrier = Carriers.CarrierFactory.of(methodType);
+        assertTrue(carrier.constructor() == Carriers.constructor(methodType),
+                "static constructor incorrect");
+        assertTrue(carrier.components() == Carriers.components(methodType),
+                "static components incorrect");
+        assertTrue(carrier.component(1) == Carriers.component(methodType, 1),
+                "static component incorrect");
+    }
+}