/*

 * Copyright (c) 2015, 2019, 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.

 */

package org.graalvm.compiler.nodes.graphbuilderconf;

import static java.lang.String.format;

import static jdk.vm.ci.services.Services.IS_BUILDING_NATIVE_IMAGE;

import static jdk.vm.ci.services.Services.IS_IN_NATIVE_IMAGE;

import static org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins.LateClassPlugins.CLOSED_LATE_CLASS_PLUGIN;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import jdk.internal.vm.compiler.collections.EconomicMap;

import jdk.internal.vm.compiler.collections.Equivalence;

import jdk.internal.vm.compiler.collections.MapCursor;

import jdk.internal.vm.compiler.collections.Pair;

import jdk.internal.vm.compiler.collections.UnmodifiableEconomicMap;

import jdk.internal.vm.compiler.collections.UnmodifiableMapCursor;

import org.graalvm.compiler.api.replacements.MethodSubstitution;

import org.graalvm.compiler.bytecode.BytecodeProvider;

import org.graalvm.compiler.core.common.SuppressFBWarnings;

import org.graalvm.compiler.debug.Assertions;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.graph.Node;

import org.graalvm.compiler.graph.iterators.NodeIterable;

import org.graalvm.compiler.nodes.ValueNode;

import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin.Receiver;

import org.graalvm.compiler.nodes.spi.Replacements;

import jdk.vm.ci.meta.MetaUtil;

import jdk.vm.ci.meta.ResolvedJavaMethod;

import jdk.vm.ci.meta.ResolvedJavaType;

import jdk.vm.ci.meta.Signature;

/**

 * Manages a set of {@link InvocationPlugin}s.

 *

 * Most plugins are registered during initialization (i.e., before

 * {@link #lookupInvocation(ResolvedJavaMethod)} or {@link #getBindings} is called). These

 * registrations can be made with {@link Registration},

 * {@link #register(InvocationPlugin, String, String, Type...)},

 * {@link #register(InvocationPlugin, Type, String, Type...)} or

 * {@link #registerOptional(InvocationPlugin, Type, String, Type...)}. Initialization is not

 * thread-safe and so must only be performed by a single thread.

 *

 * Plugins that are not guaranteed to be made during initialization must use

 * {@link LateRegistration}.

 */

public class InvocationPlugins {

    public static class InvocationPluginReceiver implements InvocationPlugin.Receiver {

        private final GraphBuilderContext parser;

        private ValueNode[] args;

        private ValueNode value;

        public InvocationPluginReceiver(GraphBuilderContext parser) {

            this.parser = parser;

        }

        @Override

        public ValueNode get(boolean performNullCheck) {

            assert args != null : "Cannot get the receiver of a static method";

            if (!performNullCheck) {

                return args[0];

            }

            if (value == null) {

                value = parser.nullCheckedValue(args[0]);

                if (value != args[0]) {

                    args[0] = value;

                }

            }

            return value;

        }

        @Override

        public boolean isConstant() {

            return args[0].isConstant();

        }

        public InvocationPluginReceiver init(ResolvedJavaMethod targetMethod, ValueNode[] newArgs) {

            if (!targetMethod.isStatic()) {

                this.args = newArgs;

                this.value = null;

                return this;

            }

            return null;

        }

    }

    /**

     * A symbol for an already resolved method.

     */

    public static class ResolvedJavaSymbol implements Type {

        private final ResolvedJavaType resolved;

        public ResolvedJavaSymbol(ResolvedJavaType type) {

            this.resolved = type;

        }

        public ResolvedJavaType getResolved() {

            return resolved;

        }

        @Override

        public String toString() {

            return resolved.toJavaName();

        }

    }

    /**

     * A symbol that is lazily {@linkplain OptionalLazySymbol#resolve() resolved} to a {@link Type}.

     */

    static class OptionalLazySymbol implements Type {

        private static final Class<?> MASK_NULL = OptionalLazySymbol.class;

        private final String name;

        private Class<?> resolved;

        OptionalLazySymbol(String name) {

            this.name = name;

            if (IS_BUILDING_NATIVE_IMAGE) {

                resolve();

            }

        }

        @Override

        public String getTypeName() {

            return name;

        }

        /**

         * Gets the resolved {@link Class} corresponding to this symbol or {@code null} if

         * resolution fails.

         */

        public Class<?> resolve() {

            if (!IS_IN_NATIVE_IMAGE && resolved == null) {

                Class<?> resolvedOrNull = resolveClass(name, true);

                resolved = resolvedOrNull == null ? MASK_NULL : resolvedOrNull;

            }

            return resolved == MASK_NULL ? null : resolved;

        }

        @Override

        public String toString() {

            return name;

        }

    }

    /**

     * Utility for {@linkplain InvocationPlugins#register registration} of invocation plugins.

     */

    public static class Registration {

        private final InvocationPlugins plugins;

        private final Type declaringType;

        private final Replacements replacements;

        private final BytecodeProvider bytecodeProvider;

        private boolean allowOverwrite;

        public Class<?> getReceiverType() {

            return Receiver.class;

        }

        public Type getDeclaringType() {

            return declaringType;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringType the class declaring the methods for which plugins will be registered

         *            via this object

         */

        public Registration(InvocationPlugins plugins, Type declaringType) {

            this.plugins = plugins;

            this.declaringType = declaringType;

            this.replacements = null;

            this.bytecodeProvider = null;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringType the class declaring the methods for which plugins will be registered

         *            via this object

         * @param replacements the current Replacements provider

         */

        public Registration(InvocationPlugins plugins, Type declaringType, Replacements replacements) {

            this.plugins = plugins;

            this.declaringType = declaringType;

            this.replacements = replacements;

            this.bytecodeProvider = replacements != null ? replacements.getDefaultReplacementBytecodeProvider() : null;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringType the class declaring the methods for which plugins will be registered

         *            via this object

         * @param replacements the current Replacements provider

         */

        public Registration(InvocationPlugins plugins, Type declaringType, Replacements replacements, BytecodeProvider bytecodeProvider) {

            this.plugins = plugins;

            this.declaringType = declaringType;

            this.replacements = replacements;

            this.bytecodeProvider = bytecodeProvider;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringClassName the name of the class class declaring the methods for which

         *            plugins will be registered via this object

         */

        public Registration(InvocationPlugins plugins, String declaringClassName) {

            this.plugins = plugins;

            this.declaringType = new OptionalLazySymbol(declaringClassName);

            this.replacements = null;

            this.bytecodeProvider = null;

        }

        /**

         * Creates an object for registering {@link InvocationPlugin}s for methods declared by a

         * given class.

         *

         * @param plugins where to register the plugins

         * @param declaringClassName the name of the class class declaring the methods for which

         *            plugins will be registered via this object

         * @param replacements the current Replacements provider

         */

        public Registration(InvocationPlugins plugins, String declaringClassName, Replacements replacements) {

            this.plugins = plugins;

            this.declaringType = new OptionalLazySymbol(declaringClassName);

            this.replacements = replacements;

            this.bytecodeProvider = replacements != null ? replacements.getDefaultReplacementBytecodeProvider() : null;

        }

        /**

         * Configures this registration to allow or disallow overwriting of invocation plugins.

         */

        public Registration setAllowOverwrite(boolean allowOverwrite) {

            this.allowOverwrite = allowOverwrite;

            return this;

        }

        /**

         * Registers a plugin for a method with no arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register0(String name, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name);

        }

        /**

         * Registers a plugin for a method with 1 argument.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register1(String name, Type arg, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg);

        }

        /**

         * Registers a plugin for a method with 2 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register2(String name, Type arg1, Type arg2, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2);

        }

        /**

         * Registers a plugin for a method with 3 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register3(String name, Type arg1, Type arg2, Type arg3, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3);

        }

        /**

         * Registers a plugin for a method with 4 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register4(String name, Type arg1, Type arg2, Type arg3, Type arg4, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4);

        }

        /**

         * Registers a plugin for a method with 5 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register5(String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5);

        }

        /**

         * Registers a plugin for a method with 6 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register6(String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, Type arg6, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5, arg6);

        }

        /**

         * Registers a plugin for a method with 7 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void register7(String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, Type arg6, Type arg7, InvocationPlugin plugin) {

            plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

        }

        /**

         * Registers a plugin for a method with no arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional0(boolean isEnabled, String name, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name);

            }

        }

        /**

         * Registers a plugin for a method with 1 argument that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional1(boolean isEnabled, String name, Type arg, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg);

            }

        }

        /**

         * Registers a plugin for a method with 2 arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional2(boolean isEnabled, String name, Type arg1, Type arg2, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2);

            }

        }

        /**

         * Registers a plugin for a method with 3 arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional3(boolean isEnabled, String name, Type arg1, Type arg2, Type arg3, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3);

            }

        }

        /**

         * Registers a plugin for a method with 4 arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional4(boolean isEnabled, String name, Type arg1, Type arg2, Type arg3, Type arg4, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4);

            }

        }

        /**

         * Registers a plugin for a method with 5 arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional5(boolean isEnabled, String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5);

            }

        }

        /**

         * Registers a plugin for a method with 6 arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional6(boolean isEnabled, String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, Type arg6, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5, arg6);

            }

        }

        /**

         * Registers a plugin for a method with 7 arguments that is conditionally enabled. This

         * ensures that {@code Replacements} is aware of this plugin.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerConditional7(boolean isEnabled, String name, Type arg1, Type arg2, Type arg3, Type arg4, Type arg5, Type arg6, Type arg7, InvocationPlugin plugin) {

            replacements.registerConditionalPlugin(plugin);

            if (isEnabled) {

                plugins.register(plugin, false, allowOverwrite, declaringType, name, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

            }

        }

        /**

         * Registers a plugin for an optional method with no arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional0(String name, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name);

        }

        /**

         * Registers a plugin for an optional method with 1 argument.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional1(String name, Type arg, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name, arg);

        }

        /**

         * Registers a plugin for an optional method with 2 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered

         */

        public void registerOptional2(String name, Type arg1, Type arg2, InvocationPlugin plugin) {

            plugins.register(plugin, true, allowOverwrite, declaringType, name, arg1, arg2);

        }

        /**

         * Registers a plugin for an optional method with 3 arguments.

         *

         * @param name the name of the method

         * @param plugin the plugin to be registered