gt:         for (int i = 0; i < nArgs; i++) {
context: /*
   * Copyright (c) 2010, 2016, 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 jdk.nashorn.internal.codegen;
  
  import static jdk.nashorn.internal.lookup.Lookup.MH;
  
  import java.lang.invoke.MethodType;
  import java.util.ArrayList;
  import java.util.List;
  import jdk.nashorn.internal.codegen.types.Type;
  import jdk.nashorn.internal.ir.Expression;
  import jdk.nashorn.internal.ir.FunctionNode;
  import jdk.nashorn.internal.runtime.ScriptFunction;
  import jdk.nashorn.internal.runtime.linker.LinkerCallSite;
  
  /**
   * Class that generates function signatures for dynamic calls
   */
  public final class FunctionSignature {
  
      /** parameter types that ASM can understand */
      private final Type[] paramTypes;
  
      /** return type that ASM can understand */
      private final Type returnType;
  
      /** valid Java descriptor string for function */
      private final String descriptor;
  
      /** {@link MethodType} for function */
      private final MethodType methodType;
  
      /**
       * Constructor
       *
       * Create a FunctionSignature given arguments as AST Nodes
       *
       * @param hasSelf   does the function have a self slot?
       * @param hasCallee does the function need a callee variable
       * @param retType   what is the return type
       * @param args      argument list of AST Nodes
       */
      public FunctionSignature(final boolean hasSelf, final boolean hasCallee, final Type retType, final List<? extends Expression> args) {
          this(hasSelf, hasCallee, retType, FunctionSignature.typeArray(args));
      }
  
      /**
       * Constructor
       *
       * Create a FunctionSignature given arguments as AST Nodes
       *
       * @param hasSelf does the function have a self slot?
       * @param hasCallee does the function need a callee variable
       * @param retType what is the return type
       * @param nArgs   number of arguments
       */
      public FunctionSignature(final boolean hasSelf, final boolean hasCallee, final Type retType, final int nArgs) {
          this(hasSelf, hasCallee, retType, FunctionSignature.objectArgs(nArgs));
      }
  
      /**
       * Constructor
       *
       * Create a FunctionSignature given argument types only
       *
       * @param hasSelf   does the function have a self slot?
       * @param hasCallee does the function have a callee slot?
       * @param retType   what is the return type
       * @param argTypes  argument list of AST Nodes
       */
      private FunctionSignature(final boolean hasSelf, final boolean hasCallee, final Type retType, final Type... argTypes) {
          final boolean isVarArg;
  
          int count = 1;
  
          if (argTypes == null) {
              isVarArg = true;
          } else {
              isVarArg = argTypes.length > LinkerCallSite.ARGLIMIT;
              count    = isVarArg ? 1 : argTypes.length;
          }
  
          if (hasCallee) {
              count++;
          }
          if (hasSelf) {
              count++;
          }
  
          paramTypes = new Type[count];
  
          int next = 0;
          if (hasCallee) {
              paramTypes[next++] = Type.typeFor(ScriptFunction.class);
          }
  
          if (hasSelf) {
              paramTypes[next++] = Type.OBJECT;
          }
  
          if (isVarArg) {
              paramTypes[next] = Type.OBJECT_ARRAY;
          } else if (argTypes != null) {
              for (int j = 0; next < count;) {
                  final Type type = argTypes[j++];
                  // TODO: for now, turn java/lang/String into java/lang/Object as we aren't as specific.
                  paramTypes[next++] = type.isObject() ? Type.OBJECT : type;
              }
          } else {
              assert false : "isVarArgs cannot be false when argTypes are null";
          }
  
          this.returnType = retType;
          this.descriptor = Type.getMethodDescriptor(returnType, paramTypes);
  
          final List<Class<?>> paramTypeList = new ArrayList<>();
          for (final Type paramType : paramTypes) {
              paramTypeList.add(paramType.getTypeClass());
          }
  
          this.methodType = MH.type(returnType.getTypeClass(), paramTypeList.toArray(new Class<?>[0]));
      }
  
      /**
       * Create a function signature given a function node, using as much
       * type information for parameters and return types that is available
       *
       * @param functionNode the function node
       */
      public FunctionSignature(final FunctionNode functionNode) {
          this(
              true,
              functionNode.needsCallee(),
              functionNode.getReturnType(),
              (functionNode.isVarArg() && !functionNode.isProgram()) ?
                  null :
                  functionNode.getParameters());
      }
  
      /**
       * Internal function that converts an array of nodes to their Types
       *
       * @param args node arg list
       *
       * @return the array of types
       */
      private static Type[] typeArray(final List<? extends Expression> args) {
          if (args == null) {
              return null;
          }
  
          final Type[] typeArray = new Type[args.size()];
  
          int pos = 0;
          for (final Expression arg : args) {
              typeArray[pos++] = arg.getType();
          }
  
          return typeArray;
      }
  
      @Override
      public String toString() {
          return descriptor;
      }
  
      /**
       * @return the number of param types
       */
      public int size() {
          return paramTypes.length;
      }
  
      /**
       * Get the param types for this function signature
       * @return cloned vector of param types
       */
      public Type[] getParamTypes() {
          return paramTypes.clone();
      }
  
      /**
       * Return the {@link MethodType} for this function signature
       * @return the method type
       */
      public MethodType getMethodType() {
          return methodType;
      }
  
      /**
       * Return the return type for this function signature
       * @return the return type
       */
      public Type getReturnType() {
          return returnType;
      }
  
      private static Type[] objectArgs(final int nArgs) {
          final Type[] array = new Type[nArgs];
  