Returns the name of the real function argument for this parameter tag.

@return array Null if there is no matching function argument.
165664
private function getArgumentTokenOfTag(): array
    {
        if ($this->argumentToken === null) {
            $this->argumentToken = $this->loadArgumentTokenOfTag();
        }

        return $this->argumentToken;
    }
396210
private function getParameterNamesReturnedBy(Node\Expr\FuncCall $getArgsCall)
    {
        $scope = $this->getCurrentScope();
        if (!$scope) {
            return array();
        }

        $allParameterNames = $scope->getParameterNames();
        $argumentNumber = isset($getArgsCall->args[0]) ? $getArgsCall->args[0] : null;
        if ($argumentNumber
            && $this->functionAnalyzer->isFunctionCallByStaticName($getArgsCall, 'func_get_arg')
            && $argumentNumber->value
            && $argumentNumber->value instanceof Node\Scalar\LNumber
        ) {
            $argumentNumber = $argumentNumber->value->value;

            return isset($allParameterNames[$argumentNumber])
                ? array($allParameterNames[$argumentNumber])
                : array();
        }

        return $allParameterNames;
    }
969710
protected function getAtoumArguments()
    {
        $inlinedArguments = array();

        foreach ($this->atoumArguments as $name => $values) {
            $inlinedArguments[] = $name;
            if (null !== $values) {
                $inlinedArguments[] = $values;
            }
        }

        return $inlinedArguments;
    }
841251
public function getArguments()
    {
        $args = [];

        foreach ($this->arguments as $name => $callable) {
            $args[$name] = $this->getArgument($name);
        }

        return $args;
    }
1319958
private function predicateName(): string
    {
        if (is_array($this->predicate)) {
            if (is_string($this->predicate[0])) {
                return $this->predicate[0] . '::' . $this->predicate[1] . '()';
            }

            return get_class($this->predicate[0]) . '->' . $this->predicate[1] . '()';
        } elseif (is_string($this->predicate)) {
            return $this->predicate . '()';
        }

        return 'a lambda function';
    }
14536
public function getName() {
		$tagNames = array(
			T_NEW_LINE             => 'T_NEW_LINE',
			T_TAB                  => 'T_TAB',
			T_SEMICOLON            => 'T_SEMICOLON',
			T_BRACES_OPEN          => 'T_BRACES_OPEN',
			T_BRACES_CLOSE         => 'T_BRACES_CLOSE',
			T_PARENTHESIS_OPEN     => 'T_PARENTHESIS_OPEN',
			T_PARENTHESIS_CLOSE    => 'T_PARENTHESIS_CLOSE',
			T_COMMA                => 'T_COMMA',
			T_EQUAL                => 'T_EQUAL',
			T_CONCAT               => 'T_CONCAT',
			T_COLON                => 'T_COLON',
			T_MINUS                => 'T_MINUS',
			T_PLUS                 => 'T_PLUS',
			T_IS_GREATER           => 'T_IS_GREATER',
			T_IS_SMALLER           => 'T_IS_SMALLER',
			T_MULTIPLY             => 'T_MULTIPLY',
			T_DIVIDE               => 'T_DIVIDE',
			T_QUESTION_MARK        => 'T_QUESTION_MARK',
			T_MODULO               => 'T_MODULO',
			T_EXCLAMATION_MARK     => 'T_EXCLAMATION_MARK',
			T_AMPERSAND            => 'T_AMPERSAND',
			T_SQUARE_BRACKET_OPEN  => 'T_SQUARE_BRACKET_OPEN',
			T_SQUARE_BRACKET_CLOSE => 'T_SQUARE_BRACKET_CLOSE',
			T_AROBAS               => 'T_AROBAS',
			T_UNKNOWN              => 'T_UNKNOWN',
			T_DOLLAR               => 'T_DOLLAR',
		);

		if (isset($tagNames[$this->id])) {
			$result = $tagNames[$this->id];
		} else {
			$result = token_name($this->id);
		}

		return $result;
	}
1100304
public String getParameterName() {
        if (parameterName == null) {
            Parameter parameter = getParameter();
            if (parameter.isNamePresent()) {
                parameterName = parameter.getName();
            }
        }

        return parameterName;
    }
490448
public static function name()
    {
        $format = static::$formats[array_rand(static::$formats)];

        $parts = array();
        foreach ($format['parts'] as $function) {
            $parts[] = call_user_func($function);
        }

        return vsprintf($format['format'], $parts);
    }
1123716
public function compileFunction()
    {
        $params = func_get_args();
        $name = array_shift($params);
        array_pop($params);
        if (function_exists($name)) {
            return $name . '(' . join(', ', $params) . ')';
        }
    }
891989
function getVariableName()
		{
			$arrBacktrace = debug_backtrace();

			//possible 'included' functions
			$arrInclude = array("include","include_once","require","require_once");

			//check for any included/required files. if found, get array of the last included file (they contain the right line numbers)
			$countBt = count($arrBacktrace);
			for($i = $countBt - 1 ; $i >= 0 ; $i--) {
				$arrCurrent = $arrBacktrace[$i];
				if(Arrays::exists("function", $arrCurrent) && (Arrays::inArray($arrCurrent["function"], $arrInclude) || (0 != strcasecmp($arrCurrent["function"], "dbug")))) {
					continue;
				}

				$arrFile = $arrCurrent;

				break;
			}

			if(isset($arrFile)) {
				$arrLines = file($arrFile["file"]);
				$code = $arrLines[($arrFile["line"]-1)];

				//find call to dBug class
				preg_match('/\bnew dBug\s*\(\s*(.+)\s*\);/i', $code, $arrMatches);

				return $arrMatches[1];
			}
			return "";
		}
546846
public function getCallbackAsString()
    {
        if (is_string($this->callback)) {
            return $this->callback;
        }

        if (is_array($this->callback) && count($this->callback) == 2) {
            list($object, $method) = array_values($this->callback);
            is_object($object) ? sprintf('object[%s]#%s', get_class($object), spl_object_hash($object)) : strval($object);

            return sprintf('[%s, %s]', $object, $method);
        }

        if (is_object($this->callback)) {
            return sprintf('object[%s]', get_class($this->callback), spl_object_hash($this->callback));
        }

        return strval($this->callback);
    }
188642
public function getParameters()
    {
        $this->parameters = array();
        $ar = parent::getParameters();
        foreach ((array) $ar as $i => $parameter) {
            $parameter->type = '';
            try {
                $ref = $parameter->getClass();
                if ($ref) {
                    $parameter->type = $ref->getName();
                }
            } catch (Exception $e) {
            }
            if ($parameter->type == '') {
                if ($parameter->isArray()) {
                    $parameter->type = 'array';
                } elseif ($parameter->isCallable()) {
                    $parameter->type = 'function';
                } elseif (isset($this->params) && isset($this->params[$i])) {
                    $parameter->type = $this->params[$i]->type;
                } else {
                    $parameter->type = 'mixed';
                }
            }
            $this->parameters[$parameter->name] = $parameter;
        }
        if (isset($this->externalParams)) {
            foreach ($this->externalParams as $param) {
                $this->parameters[$param->name] = $param;
            }
        }

        return $this->parameters;
    }
676626
public static function getParamsFromCallMap($function_id)
    {
        $call_map = self::getCallMap();

        $call_map_key = strtolower($function_id);

        if (!isset($call_map[$call_map_key])) {
            return null;
        }

        $call_map_functions = [];
        $call_map_functions[] = $call_map[$call_map_key];

        for ($i = 1; $i < 10; ++$i) {
            if (!isset($call_map[$call_map_key . '\'' . $i])) {
                break;
            }

            $call_map_functions[] = $call_map[$call_map_key . '\'' . $i];
        }

        $function_type_options = [];

        foreach ($call_map_functions as $call_map_function_args) {
            array_shift($call_map_function_args);

            $function_types = [];

            /** @var string $arg_name - key type changed with above array_shift */
            foreach ($call_map_function_args as $arg_name => $arg_type) {
                $by_reference = false;
                $optional = false;
                $variadic = false;

                if ($arg_name[0] === '&') {
                    $arg_name = substr($arg_name, 1);
                    $by_reference = true;
                }

                if (substr($arg_name, -1) === '=') {
                    $arg_name = substr($arg_name, 0, -1);
                    $optional = true;
                }

                if (substr($arg_name, 0, 3) === '...') {
                    $arg_name = substr($arg_name, 3);
                    $variadic = true;
                }

                $param_type = $arg_type
                    ? Type::parseString($arg_type)
                    : Type::getMixed();

                $function_types[] = new FunctionLikeParameter(
                    $arg_name,
                    $by_reference,
                    $param_type,
                    null,
                    null,
                    $optional,
                    false,
                    $variadic
                );
            }

            $function_type_options[] = $function_types;
        }

        return $function_type_options;
    }
702871
public function getTaskName()
    {
        return $this->realThing === null || !$this->realThing instanceof Task
            ? parent::getTaskName()
            : $this->realThing->getTaskName();
    }
689158
public function getArgumentDefaults()
    {
        $values = [];
        foreach ($this->arguments as $argument) {
            $values[$argument->getName()] = $argument->getDefault();
        }

        return $values;
    }
202281
private function get_named_arguments() : array {
		// name the parameters
		$named_arguments = [];

		if ( array_key_exists( 'expects', $this->routes[ $this->__method_name ] ) ) {
			$expects = $this->routes[ $this->__method_name ]['expects'];

			foreach ( $expects as $index => $parameter_name ) {
				if ( array_key_exists( $index, $this->__arguments ) ) {
					$named_arguments[ $parameter_name ] = $this->__arguments[ $index ];
				}
			}
		}

		return $named_arguments;
	}
714932
public function getName()
    {
        if ($this->_name === null) {
            $endpoint = namespaceSplit(get_class($this));
            $endpoint = substr(end($endpoint), 0, -8);

            $inflectMethod = $this->getInflectionMethod();
            $this->_name = Inflector::$inflectMethod($endpoint);
        }

        return $this->_name;
    }