/*

 * Copyright (c) 2012, 2013, 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.invoke;

import jdk.internal.org.objectweb.asm.*;

import sun.invoke.util.BytecodeDescriptor;

import sun.misc.Unsafe;

import sun.security.action.GetPropertyAction;

import java.io.FilePermission;

import java.io.Serializable;

import java.lang.reflect.Constructor;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.LinkedHashSet;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.PropertyPermission;

import java.util.Set;

import static jdk.internal.org.objectweb.asm.Opcodes.*;

/**

 * Lambda metafactory implementation which dynamically creates an

 * inner-class-like class per lambda callsite.

 *

 * @see LambdaMetafactory

 */

/* package */ final class InnerClassLambdaMetafactory extends AbstractValidatingLambdaMetafactory {

    private static final Unsafe UNSAFE = Unsafe.getUnsafe();

    private static final int CLASSFILE_VERSION = 52;

    private static final String METHOD_DESCRIPTOR_VOID = Type.getMethodDescriptor(Type.VOID_TYPE);

    private static final String JAVA_LANG_OBJECT = "java/lang/Object";

    private static final String NAME_CTOR = "<init>";

    private static final String NAME_FACTORY = "get$Lambda";

    //Serialization support

    private static final String NAME_SERIALIZED_LAMBDA = "java/lang/invoke/SerializedLambda";

    private static final String NAME_NOT_SERIALIZABLE_EXCEPTION = "java/io/NotSerializableException";

    private static final String DESCR_METHOD_WRITE_REPLACE = "()Ljava/lang/Object;";

    private static final String DESCR_METHOD_WRITE_OBJECT = "(Ljava/io/ObjectOutputStream;)V";

    private static final String DESCR_METHOD_READ_OBJECT = "(Ljava/io/ObjectInputStream;)V";

    private static final String NAME_METHOD_WRITE_REPLACE = "writeReplace";

    private static final String NAME_METHOD_READ_OBJECT = "readObject";

    private static final String NAME_METHOD_WRITE_OBJECT = "writeObject";

    private static final String DESCR_CTOR_SERIALIZED_LAMBDA

            = MethodType.methodType(void.class,

                                    Class.class,

                                    String.class, String.class, String.class,

                                    int.class, String.class, String.class, String.class,

                                    String.class,

                                    Object[].class).toMethodDescriptorString();

    private static final String DESCR_CTOR_NOT_SERIALIZABLE_EXCEPTION

            = MethodType.methodType(void.class, String.class).toMethodDescriptorString();

    private static final String[] SER_HOSTILE_EXCEPTIONS = new String[] {NAME_NOT_SERIALIZABLE_EXCEPTION};

    private static final String[] EMPTY_STRING_ARRAY = new String[0];

    // Used to ensure that each spun class name is unique

    private static final AtomicInteger counter = new AtomicInteger(0);

    // See context values in AbstractValidatingLambdaMetafactory

    private final String implMethodClassName;        // Name of type containing implementation "CC"

    private final String implMethodName;             // Name of implementation method "impl"

    private final String implMethodDesc;             // Type descriptor for implementation methods "(I)Ljava/lang/String;"

    private final Class<?> implMethodReturnClass;    // class for implementaion method return type "Ljava/lang/String;"

    private final MethodType constructorType;        // Generated class constructor type "(CC)void"

    private final ClassWriter cw;                    // ASM class writer

    private final String[] argNames;                 // Generated names for the constructor arguments

    private final String[] argDescs;                 // Type descriptors for the constructor arguments

    private final String lambdaClassName;            // Generated name for the generated class "X$$Lambda$1"

    /**

     * General meta-factory constructor, supporting both standard cases and

     * allowing for uncommon options such as serialization or bridging.

     *

     * @param caller Stacked automatically by VM; represents a lookup context

     *               with the accessibility privileges of the caller.

     * @param invokedType Stacked automatically by VM; the signature of the

     *                    invoked method, which includes the expected static

     *                    type of the returned lambda object, and the static

     *                    types of the captured arguments for the lambda.  In

     *                    the event that the implementation method is an

     *                    instance method, the first argument in the invocation

     *                    signature will correspond to the receiver.

     * @param samMethodName Name of the method in the functional interface to

     *                      which the lambda or method reference is being

     *                      converted, represented as a String.

     * @param samMethodType Type of the method in the functional interface to

     *                      which the lambda or method reference is being

     *                      converted, represented as a MethodType.

     * @param implMethod The implementation method which should be called (with

     *                   suitable adaptation of argument types, return types,

     *                   and adjustment for captured arguments) when methods of

     *                   the resulting functional interface instance are invoked.

     * @param instantiatedMethodType The signature of the primary functional

     *                               interface method after type variables are

     *                               substituted with their instantiation from

     *                               the capture site

     * @param isSerializable Should the lambda be made serializable?  If set,

     *                       either the target type or one of the additional SAM

     *                       types must extend {@code Serializable}.

     * @param markerInterfaces Additional interfaces which the lambda object

     *                       should implement.

     * @param additionalBridges Method types for additional signatures to be

     *                          bridged to the implementation method

     * @throws LambdaConversionException If any of the meta-factory protocol

     * invariants are violated

     */

    public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,

                                       MethodType invokedType,

                                       String samMethodName,

                                       MethodType samMethodType,

                                       MethodHandle implMethod,

                                       MethodType instantiatedMethodType,

                                       boolean isSerializable,

                                       Class<?>[] markerInterfaces,

                                       MethodType[] additionalBridges)

            throws LambdaConversionException {

        super(caller, invokedType, samMethodName, samMethodType,

              implMethod, instantiatedMethodType,

              isSerializable, markerInterfaces, additionalBridges);

        implMethodClassName = implDefiningClass.getName().replace('.', '/');

        implMethodName = implInfo.getName();

        implMethodDesc = implMethodType.toMethodDescriptorString();

        implMethodReturnClass = (implKind == MethodHandleInfo.REF_newInvokeSpecial)

                ? implDefiningClass

                : implMethodType.returnType();

        constructorType = invokedType.changeReturnType(Void.TYPE);

        lambdaClassName = targetClass.getName().replace('.', '/') + "$$Lambda$" + counter.incrementAndGet();

        cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);

        int parameterCount = invokedType.parameterCount();

        if (parameterCount > 0) {

            argNames = new String[parameterCount];

            argDescs = new String[parameterCount];

            for (int i = 0; i < parameterCount; i++) {

                argNames[i] = "arg$" + (i + 1);

                argDescs[i] = BytecodeDescriptor.unparse(invokedType.parameterType(i));

            }

        } else {

            argNames = argDescs = EMPTY_STRING_ARRAY;

        }

    }

    /**

     * Build the CallSite. Generate a class file which implements the functional

     * interface, define the class, if there are no parameters create an instance

     * of the class which the CallSite will return, otherwise, generate handles

     * which will call the class' constructor.

     *

     * @return a CallSite, which, when invoked, will return an instance of the

     * functional interface

     * @throws ReflectiveOperationException

     * @throws LambdaConversionException If properly formed functional interface

     * is not found

     */

    @Override

    CallSite buildCallSite() throws LambdaConversionException {

        final Class<?> innerClass = spinInnerClass();

        if (invokedType.parameterCount() == 0) {

            final Constructor[] ctrs = AccessController.doPrivileged(

                    new PrivilegedAction<Constructor[]>() {

                @Override

                public Constructor[] run() {

                    Constructor<?>[] ctrs = innerClass.getDeclaredConstructors();

                    if (ctrs.length == 1) {

                        // The lambda implementing inner class constructor is private, set

                        // it accessible (by us) before creating the constant sole instance

                        ctrs[0].setAccessible(true);

                    }

                    return ctrs;

                }

                    });

            if (ctrs.length != 1) {

                throw new LambdaConversionException("Expected one lambda constructor for "

                        + innerClass.getCanonicalName() + ", got " + ctrs.length);

            }

            try {

                Object inst = ctrs[0].newInstance();

                return new ConstantCallSite(MethodHandles.constant(samBase, inst));

            }

            catch (ReflectiveOperationException e) {

                throw new LambdaConversionException("Exception instantiating lambda object", e);

            }

        } else {

            try {

                UNSAFE.ensureClassInitialized(innerClass);

                return new ConstantCallSite(

                        MethodHandles.Lookup.IMPL_LOOKUP

                             .findStatic(innerClass, NAME_FACTORY, invokedType));

            }

            catch (ReflectiveOperationException e) {

                throw new LambdaConversionException("Exception finding constructor", e);

            }

        }

    }

    /**

     * Generate a class file which implements the functional

     * interface, define and return the class.

     *

     * @implNote The class that is generated does not include signature

     * information for exceptions that may be present on the SAM method.

     * This is to reduce classfile size, and is harmless as checked exceptions

     * are erased anyway, no one will ever compile against this classfile,

     * and we make no guarantees about the reflective properties of lambda

     * objects.

     *

     * @return a Class which implements the functional interface

     * @throws LambdaConversionException If properly formed functional interface

     * is not found

     */

    private Class<?> spinInnerClass() throws LambdaConversionException {

        String[] interfaces;

        String samIntf = samBase.getName().replace('.', '/');

        boolean accidentallySerializable = !isSerializable && Serializable.class.isAssignableFrom(samBase);

        if (markerInterfaces.length == 0) {

            interfaces = new String[]{samIntf};

        } else {

            // Assure no duplicate interfaces (ClassFormatError)

            Set<String> itfs = new LinkedHashSet<>(markerInterfaces.length + 1);

            itfs.add(samIntf);

            for (Class<?> markerInterface : markerInterfaces) {

                itfs.add(markerInterface.getName().replace('.', '/'));

                accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(markerInterface);

            }

            interfaces = itfs.toArray(new String[itfs.size()]);

        }

        cw.visit(CLASSFILE_VERSION, ACC_SUPER + ACC_FINAL + ACC_SYNTHETIC,

                 lambdaClassName, null,

                 JAVA_LANG_OBJECT, interfaces);

        // Generate final fields to be filled in by constructor

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

            FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_FINAL,

                                            argNames[i],

                                            argDescs[i],

                                            null, null);

            fv.visitEnd();

        }

        generateConstructor();

        if (invokedType.parameterCount() != 0) {

            generateFactory();

        }

        // Forward the SAM method

        MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, samMethodName,

                                          samMethodType.toMethodDescriptorString(), null, null);

        new ForwardingMethodGenerator(mv).generate(samMethodType);

        // Forward the bridges

        if (additionalBridges != null) {

            for (MethodType mt : additionalBridges) {

                mv = cw.visitMethod(ACC_PUBLIC|ACC_BRIDGE, samMethodName,

                                    mt.toMethodDescriptorString(), null, null);

                new ForwardingMethodGenerator(mv).generate(mt);

            }

        }

        if (isSerializable)

            generateSerializationFriendlyMethods();

        else if (accidentallySerializable)

            generateSerializationHostileMethods();

        cw.visitEnd();

        // Define the generated class in this VM.

        final byte[] classBytes = cw.toByteArray();

        // If requested, dump out to a file for debugging purposes

        if (dumper != null) {

            AccessController.doPrivileged(new PrivilegedAction<Void>() {

                @Override

                public Void run() {

                    dumper.dumpClass(lambdaClassName, classBytes);

                    return null;

                }

            }, null,

            new FilePermission("<<ALL FILES>>", "read, write"),

            // createDirectories may need it

            new PropertyPermission("user.dir", "read"));

        }

        return UNSAFE.defineAnonymousClass(targetClass, classBytes, null);

    }

    /**

     * Generate the factory method for the class

     */

    private void generateFactory() {

        MethodVisitor m = cw.visitMethod(ACC_PRIVATE | ACC_STATIC, NAME_FACTORY, invokedType.toMethodDescriptorString(), null, null);

        m.visitCode();

        m.visitTypeInsn(NEW, lambdaClassName);

        m.visitInsn(Opcodes.DUP);

        int parameterCount = invokedType.parameterCount();

        for (int typeIndex = 0, varIndex = 0; typeIndex < parameterCount; typeIndex++) {

            Class<?> argType = invokedType.parameterType(typeIndex);

            m.visitVarInsn(getLoadOpcode(argType), varIndex);

            varIndex += getParameterSize(argType);

        }

        m.visitMethodInsn(INVOKESPECIAL, lambdaClassName, NAME_CTOR, constructorType.toMethodDescriptorString());

        m.visitInsn(ARETURN);

        m.visitMaxs(-1, -1);

        m.visitEnd();

    }

    /**

     * Generate the constructor for the class

     */

    private void generateConstructor() {

        // Generate constructor

        MethodVisitor ctor = cw.visitMethod(ACC_PRIVATE, NAME_CTOR,

                                            constructorType.toMethodDescriptorString(), null, null);

        ctor.visitCode();

        ctor.visitVarInsn(ALOAD, 0);

        ctor.visitMethodInsn(INVOKESPECIAL, JAVA_LANG_OBJECT, NAME_CTOR,

                             METHOD_DESCRIPTOR_VOID);

        int parameterCount = invokedType.parameterCount();

        for (int i = 0, lvIndex = 0; i < parameterCount; i++) {

            ctor.visitVarInsn(ALOAD, 0);

            Class<?> argType = invokedType.parameterType(i);

            ctor.visitVarInsn(getLoadOpcode(argType), lvIndex + 1);

            lvIndex += getParameterSize(argType);

            ctor.visitFieldInsn(PUTFIELD, lambdaClassName, argNames[i], argDescs[i]);

        }

        ctor.visitInsn(RETURN);

        // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored

        ctor.visitMaxs(-1, -1);

        ctor.visitEnd();

    }

    /**

     * Generate a writeReplace method that supports serialization

     */

    private void generateSerializationFriendlyMethods() {

        TypeConvertingMethodAdapter mv

                = new TypeConvertingMethodAdapter(

                    cw.visitMethod(ACC_PRIVATE + ACC_FINAL,

                    NAME_METHOD_WRITE_REPLACE, DESCR_METHOD_WRITE_REPLACE,

                    null, null));

        mv.visitCode();

        mv.visitTypeInsn(NEW, NAME_SERIALIZED_LAMBDA);

        mv.visitInsn(DUP);

        mv.visitLdcInsn(Type.getType(targetClass));

        mv.visitLdcInsn(invokedType.returnType().getName().replace('.', '/'));

        mv.visitLdcInsn(samMethodName);

        mv.visitLdcInsn(samMethodType.toMethodDescriptorString());

        mv.visitLdcInsn(implInfo.getReferenceKind());

        mv.visitLdcInsn(implInfo.getDeclaringClass().getName().replace('.', '/'));

        mv.visitLdcInsn(implInfo.getName());

        mv.visitLdcInsn(implInfo.getMethodType().toMethodDescriptorString());

        mv.visitLdcInsn(instantiatedMethodType.toMethodDescriptorString());

        mv.iconst(argDescs.length);

        mv.visitTypeInsn(ANEWARRAY, JAVA_LANG_OBJECT);

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

            mv.visitInsn(DUP);

            mv.iconst(i);

            mv.visitVarInsn(ALOAD, 0);

            mv.visitFieldInsn(GETFIELD, lambdaClassName, argNames[i], argDescs[i]);

            mv.boxIfTypePrimitive(Type.getType(argDescs[i]));

            mv.visitInsn(AASTORE);

        }

        mv.visitMethodInsn(INVOKESPECIAL, NAME_SERIALIZED_LAMBDA, NAME_CTOR,

                DESCR_CTOR_SERIALIZED_LAMBDA);

        mv.visitInsn(ARETURN);

        // Maxs computed by ClassWriter.COMPUTE_MAXS, these arguments ignored

        mv.visitMaxs(-1, -1);

        mv.visitEnd();

    }

    /**

     * Generate a readObject/writeObject method that is hostile to serialization

     */

    private void generateSerializationHostileMethods() {

        MethodVisitor mv = cw.visitMethod(ACC_PRIVATE + ACC_FINAL,

                                          NAME_METHOD_WRITE_OBJECT, DESCR_METHOD_WRITE_OBJECT,

                                          null, SER_HOSTILE_EXCEPTIONS);

        mv.visitCode();

        mv.visitTypeInsn(NEW, NAME_NOT_SERIALIZABLE_EXCEPTION);

        mv.visitInsn(DUP);

        mv.visitLdcInsn("Non-serializable lambda");

        mv.visitMethodInsn(INVOKESPECIAL, NAME_NOT_SERIALIZABLE_EXCEPTION, NAME_CTOR,

                           DESCR_CTOR_NOT_SERIALIZABLE_EXCEPTION);

        mv.visitInsn(ATHROW);

        mv.visitMaxs(-1, -1);

        mv.visitEnd();

        mv = cw.visitMethod(ACC_PRIVATE + ACC_FINAL,

                            NAME_METHOD_READ_OBJECT, DESCR_METHOD_READ_OBJECT,

                            null, SER_HOSTILE_EXCEPTIONS);

        mv.visitCode();

        mv.visitTypeInsn(NEW, NAME_NOT_SERIALIZABLE_EXCEPTION);

        mv.visitInsn(DUP);

        mv.visitLdcInsn("Non-serializable lambda");

        mv.visitMethodInsn(INVOKESPECIAL, NAME_NOT_SERIALIZABLE_EXCEPTION, NAME_CTOR,

                           DESCR_CTOR_NOT_SERIALIZABLE_EXCEPTION);

        mv.visitInsn(ATHROW);

        mv.visitMaxs(-1, -1);

        mv.visitEnd();

    }

    /**

     * This class generates a method body which calls the lambda implementation

     * method, converting arguments, as needed.

     */

    private class ForwardingMethodGenerator extends TypeConvertingMethodAdapter {

        ForwardingMethodGenerator(MethodVisitor mv) {

            super(mv);

        }

        void generate(MethodType methodType) {

            visitCode();

            if (implKind == MethodHandleInfo.REF_newInvokeSpecial) {

                visitTypeInsn(NEW, implMethodClassName);

                visitInsn(DUP);

            }

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

                visitVarInsn(ALOAD, 0);

                visitFieldInsn(GETFIELD, lambdaClassName, argNames[i], argDescs[i]);

            }

            convertArgumentTypes(methodType);

            // Invoke the method we want to forward to

            visitMethodInsn(invocationOpcode(), implMethodClassName,

                            implMethodName, implMethodDesc,

                            implDefiningClass.isInterface());

            // Convert the return value (if any) and return it

            // Note: if adapting from non-void to void, the 'return'

            // instruction will pop the unneeded result

            Class<?> samReturnClass = methodType.returnType();

            convertType(implMethodReturnClass, samReturnClass, samReturnClass);

            visitInsn(getReturnOpcode(samReturnClass));

            // Maxs computed by ClassWriter.COMPUTE_MAXS,these arguments ignored

            visitMaxs(-1, -1);

            visitEnd();

        }

        private void convertArgumentTypes(MethodType samType) {

            int lvIndex = 0;

            boolean samIncludesReceiver = implIsInstanceMethod &&

                                                   invokedType.parameterCount() == 0;

            int samReceiverLength = samIncludesReceiver ? 1 : 0;

            if (samIncludesReceiver) {

                // push receiver

                Class<?> rcvrType = samType.parameterType(0);

                visitVarInsn(getLoadOpcode(rcvrType), lvIndex + 1);

                lvIndex += getParameterSize(rcvrType);

                convertType(rcvrType, implDefiningClass, instantiatedMethodType.parameterType(0));

            }

            int samParametersLength = samType.parameterCount();

            int argOffset = implMethodType.parameterCount() - samParametersLength;

            for (int i = samReceiverLength; i < samParametersLength; i++) {

                Class<?> argType = samType.parameterType(i);

                visitVarInsn(getLoadOpcode(argType), lvIndex + 1);

                lvIndex += getParameterSize(argType);

                convertType(argType, implMethodType.parameterType(argOffset + i), instantiatedMethodType.parameterType(i));

            }

        }

        private int invocationOpcode() throws InternalError {

            switch (implKind) {

                case MethodHandleInfo.REF_invokeStatic:

                    return INVOKESTATIC;

                case MethodHandleInfo.REF_newInvokeSpecial:

                    return INVOKESPECIAL;

                 case MethodHandleInfo.REF_invokeVirtual:

                    return INVOKEVIRTUAL;

                case MethodHandleInfo.REF_invokeInterface:

                    return INVOKEINTERFACE;

                case MethodHandleInfo.REF_invokeSpecial:

                    return INVOKESPECIAL;

                default:

                    throw new InternalError("Unexpected invocation kind: " + implKind);

            }

        }

    }

    static int getParameterSize(Class<?> c) {

        if (c == Void.TYPE) {

            return 0;

        } else if (c == Long.TYPE || c == Double.TYPE) {

            return 2;

        }

        return 1;

    }

    static int getLoadOpcode(Class<?> c) {

        if(c == Void.TYPE) {

            throw new InternalError("Unexpected void type of load opcode");

        }

        return ILOAD + getOpcodeOffset(c);

    }

    static int getReturnOpcode(Class<?> c) {

        if(c == Void.TYPE) {

            return RETURN;

        }

        return IRETURN + getOpcodeOffset(c);

    }

    private static int getOpcodeOffset(Class<?> c) {

        if (c.isPrimitive()) {

            if (c == Long.TYPE) {

                return 1;

            } else if (c == Float.TYPE) {

                return 2;

            } else if (c == Double.TYPE) {

                return 3;

            }

            return 0;

        } else {

            return 4;

        }

    }

}