reserved method parameter
437429
public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
    ActionMapping mapping = new ActionMapping();
    parseNameAndNamespace(RequestUtils.getServletPath(request), mapping);

    String method = request.getParameter(MethodParam);
    if (Strings.isNotEmpty(method)) mapping.setMethod(method);
    return mapping;
  }
972592
protected void reserve(long reservedDelta)
                    throws ObjectManagerException
    {

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "reserve",
                        new Object[] { new Long(reservedDelta) }
                            );
        long unavailable = reserveLogFileSpace(reservedDelta);
        if (unavailable != 0) {
            if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                trace.exit(this, cclass,
                           "reserve",
                           new Object[] { "via LogFileFullException", new Long(unavailable), new Long(reservedDelta) }
                                );
            throw new LogFileFullException(this
                                           , reservedDelta
                                           , reservedDelta
                                           , reservedDelta - unavailable);
        } // if (unavailable != 0).

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       "reserve");
    }
1096042
def method_missing(name, *args)
      name = name.to_s
      last_char = name[-1,1]
      super(name, *args) unless last_char == "=" || last_char == "?"
      attr_name = name[0..-2].to_sym # :foo for 'foo=' or 'foo?'
      if last_char == "="
        @options[attr_name] = args.at(0)
      else
        @options[attr_name]
      end
    end
1176647
def disable_constant(parameterized):
    
    params = parameterized.params().values()
    constants = [p.constant for p in params]
    for p in params:
        p.constant = False
    try:
        yield
    except:
        raise
    finally:
        for (p, const) in zip(params, constants):
            p.constant = const
710703
function () {
            /*  determine parameters  */
            var params = $cs.params("spool", arguments, {
                name:  { pos: 0,     req: true },
                ctx:   { pos: 1,     req: true },
                func:  { pos: 2,     req: true },
                args:  { pos: "...", def: []   }
            });

            /*  sanity check parameters  */
            if (!_cs.istypeof(params.func).match(/^(string|function)$/))
                throw _cs.exception("spool", "invalid function parameter (neither function object nor method name)");
            if (_cs.istypeof(params.func) === "string") {
                if (_cs.istypeof(params.ctx[params.func]) !== "function")
                    throw _cs.exception("spool", "invalid method name: \"" + params.func + "\"");
                params.func = params.ctx[params.func];
            }

            /*  spool cleanup action  */
            if (!_cs.isdefined(this.__spool[params.name]))
                this.__spool[params.name] = [];
            this.__spool[params.name].push(params);
            return;
        }
216658
def method_missing(method_id, *args)
      if [:get, :post, :put, :delete].include?(method_id)
        path, options = *args
        options ||= {}
        options[:query] = (default_params.merge(options[:query] || {}))
        options[:headers] = (self.class.default_options[:headers].merge(options[:headers] || {}))

        CrowdFlower.request_hook.call(method_id, path, options) do
          self.class.send(method_id, url(path), options)
        end
      else
        super
      end
    end
485475
private function _checkUnusedFunctionParameters() {
		if ($this->_isActive('checkUnusedFunctionParameters')) {

			// If the docblock is inherited, this means that the function implements a parent function
			// We may have some unused parameters in this case, we don't generate a warnings
			if (!$this->statementStack->getParentStackItem()->docblocInheritDoc) {

				foreach ($this->_functionParameters as $variableName => $value) {
					if ($value !== "used") {
						$msg = $this->_getMessage('UNUSED_FUNCTION_PARAMETER', $this->_currentFunctionName, $variableName);
						$this->_writeError('checkUnusedFunctionParameters', $msg);
					}
				}
			}
		}
	}
474816
private static Object invokeOrDie(
      final Method method, final Object object, final Object... params) {
    try {
      return method.invoke(object, params);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(
        "Couldn't use Java reflection to implement protocol message " +
        "reflection.", e);
    } catch (InvocationTargetException e) {
      final Throwable cause = e.getCause();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else if (cause instanceof Error) {
        throw (Error) cause;
      } else {
        throw new RuntimeException(
          "Unexpected exception thrown by generated accessor method.", cause);
      }
    }
  }
120483
private String typeParameters(Options opt, ParameterizedType t) {
	if (t == null)
	    return "";
	StringBuffer tp = new StringBuffer(1000).append("&lt;");
	Type args[] = t.typeArguments();
	for (int i = 0; i < args.length; i++) {
	    tp.append(type(opt, args[i], true));
	    if (i != args.length - 1)
		tp.append(", ");
	}
	return tp.append("&gt;").toString();
    }
210187
private void storeArgs(Method method, Array methodArgs) {

	Class[] pmt = method.getParameterTypes();
	Method[] args;
	synchronized (methodArgs) {
	    Object o = methodArgs.get(pmt.length + 1, null);
	    if (o == null) {
		args = new Method[1];
		methodArgs.setEL(pmt.length + 1, args);
	    }
	    else {
		Method[] ms = (Method[]) o;
		args = new Method[ms.length + 1];
		for (int i = 0; i < ms.length; i++) {
		    args[i] = ms[i];
		}
		methodArgs.setEL(pmt.length + 1, args);
	    }
	}
	args[args.length - 1] = method;
    }
107192
private String createMethodSignature(Method method)
   {
      StringBuilder sb = new StringBuilder();
      sb.append("(");
      for (Class<?> type : method.getParameterTypes())
      {
         sb.append(getTypeString(type));
      }
      sb.append(")");
      Class<?> type = method.getReturnType();
      if (type.getName().equals("void"))
      {
         sb.append("V");
      }
      else
      {
         sb.append(getTypeString(type));
      }
      return sb.toString();
   }
1259667
void parameter(String name, Object value) {
        Preconditions.checkNotNull(name, "parameter name cannot be null");
        if (value instanceof Observable)
            throw new IllegalArgumentException(
                    "use parameters() method not the parameter() method for an Observable");
        this.parameters = parameters.concatWith(Observable.just(new Parameter(name, value)));
    }
1037743
function callApi(method, parameters, callback) {

    if (typeof parameters === 'undefined') {
        throw new Error('undefined is not a valid parameters object.');
    }

    if( typeof parameters !== 'object' ){
        throw new Error('valid parameters object required.');
    }

    var opts = this.options;

    var noCallback = !callback || typeof callback !== 'function';
    let noApiKey = typeof opts.API_KEY !== 'string' || opts.API_KEY.length === 0 || typeof opts.API_SECRET !== 'string' || opts.API_SECRET.length === 0;
    if( noApiKey ){
        if( noCallback ){
            throw new Error('API key and API secret required.');
        }
        return callback(new Error("API key and API secret required."));
    }

    opts.method = method;

    //
    // final API url with hashes
    //
    let url = makeApiUrl(opts, parameters);

    let reqOptions = {
        uri: url,
        json: true,
        timeout: process.env.CF_TIMEOUT || opts.DEFAULT_TIMEOUT
    };


    //
    // callback not exists, just return the request modules Request class instance for event
    //
    if( noCallback ){
        return new Request(reqOptions);
    }

    //
    // callback exists, return Request for streaming and handle callback for error handling and custom formatted data
    //
    return callRequest(reqOptions, handleCallback.bind(null,callback) );
}
654862
private void callHandleMethod(Method method, Object instance, ApiZone apiZone,
            Object userAgent) {
        ReflectMethodUtil.invokeHandleMethod(method, instance, context, apiZone, userAgent);
    }
375856
@Override
    public <R, T extends Object> R callMethod(final String methodName, final T argument) throws CouldNotPerformException, InterruptedException {
        return callMethod(methodName, argument, -1);
    }
1283614
public static void addParameter(MethodDeclaration method, Parameter parameter) {
        List<Parameter> parameters = method.getParameters();
        if (parameters == null) {
            parameters = new ArrayList<Parameter>();
            method.setParameters(parameters);
        }
        parameters.add(parameter);
    }
68517
def method_missing(m, *args, &block)
      if args.any?
        args = args.first if args.length == 1
        @var << { m.to_sym => args }
        instance_variable_set "@#{m}", args
      else
        instance_variable_get "@#{m}"
      end
    end