Class FunctionObject

rhino/src/main/java/org/mozilla/javascript/FunctionObject.java:19–543

import java.lang.reflect.Modifier;

public class FunctionObject extends BaseFunction {
    @Serial private static final long serialVersionUID = 8880062939740158370L;

    /**
     * Create a JavaScript function object from a Java method.
     *
     * <p>The {@code member} argument must be either a java.lang.reflect.Method or a
     * java.lang.reflect.Constructor and must match one of two forms.
     *
     * <p>The first form is a member with zero or more parameters of the following types: Object,
     * String, boolean, Scriptable, int, or double. The Long type is not supported because the
     * double representation of a long (which is the EMCA-mandated storage type for Numbers) may
     * lose precision. If the member is a Method, the return value must be void or one of the types
     * allowed for parameters.
     *
     * <p>The runtime will perform appropriate conversions based upon the type of the parameter. A
     * parameter type of Object specifies that no conversions are to be done. A parameter of type
     * String will use Context.toString to convert arguments. Similarly, parameters of type double,
     * boolean, and Scriptable will cause Context.toNumber, Context.toBoolean, and Context.toObject,
     * respectively, to be called.
     *
     * <p>If the method is not static, the Java 'this' value will correspond to the JavaScript
     * 'this' value. Any attempt to call the function with a 'this' value that is not of the right
     * Java type will result in an error.
     *
     * <p>The second form is the variable arguments (or "varargs") form. If the FunctionObject will
     * be used as a constructor, the member must have the following parameters
     *
     * <pre>
     *      (Context cx, Object[] args, Function ctorObj,
     *       boolean inNewExpr)</pre>
     *
     * and if it is a Method, be static and return an Object result.
     *
     * <p>Otherwise, if the FunctionObject will <i>not</i> be used to define a constructor, the
     * member must be a static Method with parameters
     *
     * <pre>
     *      (Context cx, Scriptable thisObj, Object[] args,
     *       Function funObj) </pre>
     *
     * and an Object result.
     *
     * <p>When the function varargs form is called as part of a function call, the {@code args}
     * parameter contains the arguments, with {@code thisObj} set to the JavaScript 'this' value.
     * {@code funObj} is the function object for the invoked function.
     *
     * <p>When the constructor varargs form is called or invoked while evaluating a {@code new}
     * expression, {@code args} contains the arguments, {@code ctorObj} refers to this
     * FunctionObject, and {@code inNewExpr} is true if and only if a {@code new} expression caused
     * the call. This supports defining a function that has different behavior when called as a
     * constructor than when invoked as a normal function call. (For example, the Boolean
     * constructor, when called as a function, will convert to boolean rather than creating a new
     * object.)
     *
     * @param name the name of the function
     * @param methodOrConstructor a java.lang.reflect.Method or a java.lang.reflect.Constructor that
     *     defines the object