import java.util.ArrayList;

import java.util.List;

import static java.lang.invoke.LambdaForm.BasicType.V_TYPE_NUM;

import static java.lang.invoke.LambdaForm.BasicType.V_TYPE_NUM;

import static java.lang.invoke.LambdaForm.BasicType.V_TYPE_NUM;

import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;

import static java.lang.invoke.MethodHandleNatives.Constants.*;

import static java.lang.invoke.MethodHandleStatics.newInternalError;

import static java.lang.invoke.MethodHandleStatics.uncaughtException;

        assert(speciesData() == speciesDataFor(form));

                return (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(I_TYPE_NUM).factory().invokeBasic(type, form, ValueConversions.widenSubword(x));

                return (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(J_TYPE_NUM).factory().invokeBasic(type, form, (long) x);

                return (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(F_TYPE_NUM).factory().invokeBasic(type, form, (float) x);

                return (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(D_TYPE_NUM).factory().invokeBasic(type, form, (double) x);

                Species_L.BMH_SPECIES, Species_L.BMH_SPECIES.getterFunction(0));

     * Return the {@link BoundMethodHandle.SpeciesData} instance representing this BMH species. All subclasses must provide a

    /*non-public*/ abstract BoundMethodHandle.SpeciesData speciesData();

    /*non-public*/ static BoundMethodHandle.SpeciesData speciesDataFor(LambdaForm form) {

        if (c instanceof SpeciesData) {

        }

        return SPECIALIZER.topSpecies();

    /*non-public*/ final int fieldCount() { return speciesData().fieldCount(); }

        int count = fieldCount();

            Class<?> fieldType = speciesData().fieldTypes().get(i);

            switch (BasicType.basicType(fieldType)) {

                case L_TYPE: return          speciesData().getter(i).invokeBasic(this);

                case I_TYPE: return (int)    speciesData().getter(i).invokeBasic(this);

                case J_TYPE: return (long)   speciesData().getter(i).invokeBasic(this);

                case F_TYPE: return (float)  speciesData().getter(i).invokeBasic(this);

                case D_TYPE: return (double) speciesData().getter(i).invokeBasic(this);

        throw new InternalError("unexpected type: " + speciesData().key()+"."+i);

            return BMH_SPECIES;

        /*non-public*/ static @Stable SpeciesData BMH_SPECIES;

                return (BoundMethodHandle) BMH_SPECIES.extendWith(L_TYPE_NUM).factory().invokeBasic(mt, lf, argL0, narg);

                return (BoundMethodHandle) BMH_SPECIES.extendWith(I_TYPE_NUM).factory().invokeBasic(mt, lf, argL0, narg);

                return (BoundMethodHandle) BMH_SPECIES.extendWith(J_TYPE_NUM).factory().invokeBasic(mt, lf, argL0, narg);

                return (BoundMethodHandle) BMH_SPECIES.extendWith(F_TYPE_NUM).factory().invokeBasic(mt, lf, argL0, narg);

                return (BoundMethodHandle) BMH_SPECIES.extendWith(D_TYPE_NUM).factory().invokeBasic(mt, lf, argL0, narg);

    /*non-public*/

    static final class SpeciesData extends ClassSpecializer<BoundMethodHandle, String, SpeciesData>.SpeciesData {

        // This array is filled in lazily, as new species come into being over time.

        @Stable final private SpeciesData[] extensions = new SpeciesData[ARG_TYPE_LIMIT];

        public SpeciesData(Specializer outer, String key) {

            outer.super(key);

        @Override

        protected String deriveClassName() {

            String typeString = deriveTypeString();

            if (typeString.isEmpty()) {

                return SimpleMethodHandle.class.getName();

            }

            return BoundMethodHandle.class.getName() + "$Species_" + typeString;

        @Override

        protected List<Class<?>> deriveFieldTypes(String key) {

            ArrayList<Class<?>> types = new ArrayList<>(key.length());

            for (int i = 0; i < key.length(); i++) {

                types.add(basicType(key.charAt(i)).basicTypeClass());

            }

            return types;

        @Override

        protected String deriveTypeString() {

            // (If/when we have to add nominal types, just inherit the more complex default.)

            return key();

        @Override

        protected MethodHandle deriveTransformHelper(MemberName transform, int whichtm) {

            if (whichtm == Specializer.TN_COPY_NO_EXTEND) {

                return factory();

            } else if (whichtm < ARG_TYPE_LIMIT) {

                return extendWith((byte) whichtm).factory();

            } else {

                throw newInternalError("bad transform");

        @Override

        protected <X> List<X> deriveTransformHelperArguments(MemberName transform, int whichtm, List<X> args, List<X> fields) {

            assert(verifyTHAargs(transform, whichtm, args, fields));

            // The rule is really simple:  Keep the first two arguments

            // the same, then put in the fields, then put any other argument.

            args.addAll(2, fields);

            return args;

        private boolean verifyTHAargs(MemberName transform, int whichtm, List<?> args, List<?> fields) {

            assert(transform == Specializer.BMH_TRANSFORMS.get(whichtm));

            assert(args.size() == transform.getMethodType().parameterCount());

            assert(fields.size() == this.fieldCount());

            final int MH_AND_LF = 2;

            if (whichtm == Specializer.TN_COPY_NO_EXTEND) {

                assert(transform.getMethodType().parameterCount() == MH_AND_LF);

            } else if (whichtm < ARG_TYPE_LIMIT) {

                assert(transform.getMethodType().parameterCount() == MH_AND_LF+1);

                final BasicType type = basicType((byte) whichtm);

                assert(transform.getParameterTypes()[MH_AND_LF] == type.basicTypeClass());

            } else {

                return false;

        /*non-public*/ SpeciesData extendWith(byte typeNum) {

            SpeciesData sd = extensions[typeNum];

            if (sd != null)  return sd;

            sd = SPECIALIZER.findSpecies(key() + BasicType.basicType(typeNum).basicTypeChar());

            extensions[typeNum] = sd;

            return sd;

    /*non-public*/

    static final Specializer SPECIALIZER = new Specializer();

    static {

        SimpleMethodHandle.BMH_SPECIES = BoundMethodHandle.SPECIALIZER.findSpecies("");

        Species_L.BMH_SPECIES = BoundMethodHandle.SPECIALIZER.findSpecies("L");

    /*non-public*/

    static final class Specializer extends ClassSpecializer<BoundMethodHandle, String, SpeciesData> {

        private static final MemberName SPECIES_DATA_ACCESSOR;

        static {

            try {

                SPECIES_DATA_ACCESSOR = IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BoundMethodHandle.class,

                        "speciesData", MethodType.methodType(BoundMethodHandle.SpeciesData.class));

            } catch (ReflectiveOperationException ex) {

                throw newInternalError("Bootstrap link error", ex);

            }

        }

        private Specializer() {

            super(  // Reified type parameters:

                    BoundMethodHandle.class, String.class, BoundMethodHandle.SpeciesData.class,

                    // Principal constructor type:

                    MethodType.methodType(void.class, MethodType.class, LambdaForm.class),

                    // Required linkage between class and species:

                    SPECIES_DATA_ACCESSOR,

                    "BMH_SPECIES",

                    BMH_TRANSFORMS);

        }

        @Override

        protected String topSpeciesKey() {

            return "";

        }

        @Override

        protected BoundMethodHandle.SpeciesData newSpeciesData(String key) {

            return new BoundMethodHandle.SpeciesData(this, key);

        }

        static final List<MemberName> BMH_TRANSFORMS;

        static final int TN_COPY_NO_EXTEND = V_TYPE_NUM;

        static {

            final Class<BoundMethodHandle> BMH = BoundMethodHandle.class;

            // copyWithExtendLIJFD + copyWith

            try {

                BMH_TRANSFORMS = List.of(

                        IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BMH, "copyWithExtendL", MethodType.methodType(BMH, MethodType.class, LambdaForm.class, Object.class)),

                        IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BMH, "copyWithExtendI", MethodType.methodType(BMH, MethodType.class, LambdaForm.class, int.class)),

                        IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BMH, "copyWithExtendJ", MethodType.methodType(BMH, MethodType.class, LambdaForm.class, long.class)),

                        IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BMH, "copyWithExtendF", MethodType.methodType(BMH, MethodType.class, LambdaForm.class, float.class)),

                        IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BMH, "copyWithExtendD", MethodType.methodType(BMH, MethodType.class, LambdaForm.class, double.class)),

                        IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, BMH, "copyWith", MethodType.methodType(BMH, MethodType.class, LambdaForm.class))

                );

            } catch (ReflectiveOperationException ex) {

                throw newInternalError("Failed resolving copyWith methods", ex);

            }

            // as it happens, there is one transform per BasicType including V_TYPE

            assert(BMH_TRANSFORMS.size() == TYPE_LIMIT);

         * Generation of concrete BMH classes.

         * A concrete BMH species is fit for binding a number of values adhering to a

         * given type pattern. Reference types are erased.

         * BMH species are cached by type pattern.

         * A BMH species has a number of fields with the concrete (possibly erased) types of

         * bound values. Setters are provided as an API in BMH. Getters are exposed as MHs,

         * which can be included as names in lambda forms.

        class Factory extends ClassSpecializer<BoundMethodHandle, String, BoundMethodHandle.SpeciesData>.Factory {

            @Override

            protected String chooseFieldName(Class<?> type, int index) {

                return "arg" + super.chooseFieldName(type, index);

        @Override

        protected Factory makeFactory() {

            return new Factory();

      }

    static SpeciesData speciesData_L()      { return Species_L.BMH_SPECIES; }

    static SpeciesData speciesData_LL()     { return SPECIALIZER.findSpecies("LL"); }

    static SpeciesData speciesData_LLL()    { return SPECIALIZER.findSpecies("LLL"); }

    static SpeciesData speciesData_LLLL()   { return SPECIALIZER.findSpecies("LLLL"); }

    static SpeciesData speciesData_LLLLL()  { return SPECIALIZER.findSpecies("LLLLL"); }