@param \ReflectionType $return_type

@return string
338534
private static function generateReturnTypeCode(\ReflectionType $return_type) : string
    {
        if ($return_type->isBuiltin()){
            return $return_type;
        }
        $_ = explode('\\', $return_type);
        return array_pop($_);
    }
1003989
public String getReturnType(HashMap<String,TypeMirror> bindingMap)
    {
        if ( _methodDecl == null || _methodDecl.getReturnType() == null )
            return "";
        
        String returnType = _methodDecl.getReturnType().toString();
        if (bindingMap != null && bindingMap.containsKey(returnType))
            return bindingMap.get(returnType).toString();

        return returnType;
    }
455492
public function newQuery($returnType=Builder::RETURN_TYPE_ELOQUENT)
    {
        $builder = $this->newQueryWithoutScopes($returnType);

        // laravel 5.1
        if (method_exists($this, 'applyGlobalScopes')) {
            return $this->applyGlobalScopes($builder);
        }

        // laravel 5.2
        foreach ($this->getGlobalScopes() as $identifier => $scope) {
            $builder->withGlobalScope($identifier, $scope);
        }

        return $builder;
    }
355795
protected function getPhpType(Type $type): string
    {
        switch ($builtinType = $type->getBuiltinType()) {
            case Type::BUILTIN_TYPE_ARRAY:
            case Type::BUILTIN_TYPE_INT:
            case Type::BUILTIN_TYPE_FLOAT:
            case Type::BUILTIN_TYPE_BOOL:
            case Type::BUILTIN_TYPE_STRING:
                return $builtinType;
            case Type::BUILTIN_TYPE_OBJECT:
                if (null !== ($className = $type->getClassName()) && is_a($className, \DateTimeInterface::class, true)) {
                    return \DateTimeInterface::class;
                }

            // no break
            default:
                return 'string';
        }
    }
341860
protected function getReturnTypeFromDocBlock(\ReflectionMethod $reflection)
    {
        $type = null;
        $phpdoc = new DocBlock($reflection);

        if ($phpdoc->hasTag('return')) {
            $type = $phpdoc->getTagsByName('return')[0]->getType();
        }

        return $type;
    }
846101
public function getTimestamp($returnType = 'string')
    {
        if (in_array($returnType, ['array', 'float', 'string'])) {
            return $this->getTimestampRaw($returnType);
        }
        return sprintf($this->lclMsgCmn('i18n_Error_UnknownReturnType'), $returnType);
    }
120713
public static function postTypeRestUrl($postType = null)
    {
        $restUrl = null;
        $postType = !$postType ? get_post_type() : $postType;
        $postTypeObj = get_post_type_object($postType);

        if ($postTypeObj && !empty($postTypeObj->show_in_rest) && !empty($postTypeObj->rest_base)) {
            $restUrl = esc_url_raw(get_rest_url() . 'wp/v2/' . $postTypeObj->rest_base);
        }

        return $restUrl;
    }
1122400
public function getOutputTypeOptions($input_type)
    {
        if (!in_array($input_type, $this->types)) {
            $input_type = $this->default_type;
        }
        return $this->map[$input_type];
    }
370489
public function returnData($data,$returnType = null,$option = null)
	{
		if(null === $returnType)
		{
			$returnType = Config::get('@.CONTROL_RETURN_TYPE');
		}
		$returnType = strtolower($returnType);
		if('json' === $returnType)
		{
			Response::setMime('json');
			exit(json_encode($data,null === $option?0:$option));
		}
		else if('xml' === $returnType)
		{
			Response::setMime('xml');
			exit(XML::toString($data));
		}
		else if('html' === $returnType)
		{
			Response::setMime('html');
			echo $data;
		}
		else
		{
			$eventData = array('data'=>$data,'returnType'=>$returnType,'option'=>$option);
			Event::trigger('YURUN_RETURN_DATA',$eventData);
		}
	}
360823
public function render($return_type = 'array') {

        # Read and delete the snackbar session
        $snackbars = $this->request->getSession()->consume($this->getConfig('session_key'));

        if ( ! $snackbars) {
            $snackbars = [];
        }

        foreach ($snackbars as &$snackbar) {
            $snackbar['button'] = $this->_button($snackbar);
        }

        # Setup the json bitmask
        $bitmask = JSON_NUMERIC_CHECK|JSON_UNESCAPED_SLASHES;
        if (Configure::read('debug')) {
            $bitmask = $bitmask|JSON_PRETTY_PRINT;
        }

        # If we want it as a window variable in a script tag
        if ($return_type === 'window_variable') {
            # Build the json object
            $snackbars_object = json_encode($snackbars, $bitmask);

            return $this->Html->tag('script', "\nwindow.snackbar_messages" . " = " . $snackbars_object . ";\n");
        }

        return $snackbars;
    }
259552
public com.sun.javadoc.Type returnType() {
        return TypeMaker.getType(env, sym.type.getReturnType(), false);
    }
1201859
public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): Type {
        $returnType = $methodReflection->getReturnType();
        $origReturnDescribe = $returnType->describe();
        $error = false;

        if ($returnType instanceof ArrayType) {
            if ($methodCall->class instanceof Name) {
                $name = $methodCall->class;
                if ((string)$name == 'parent') {
                    $scopeName = $scope->getClassReflection()->getName();
                    if (strEndsWith($scopeName, 'DAO')) {
                        $returnType = $this->copyArrayType($returnType, new ObjectType(strLeft($scopeName, -3)));
                    } else $error = true(echoPre('(1) '.simpleClassName(static::$className).'::'.$methodCall->name.'() encountered unexpected callee class name: '.$scopeName));
                } else     $error = true(echoPre('(2) '.simpleClassName(static::$className).'::'.$methodCall->name.'() cannot resolve callee of static method call: name "'.$name.'"'));
            } else         $error = true(echoPre('(3) '.simpleClassName(static::$className).'::'.$methodCall->name.'() cannot resolve callee of static method call: class($methodCall->class) = '.get_class($methodCall->class)));
        } else             $error = true(echoPre('(4) '.simpleClassName(static::$className).'::'.$methodCall->name.'() encountered unexpected return type: '.get_class($returnType).' => '.$returnType->describe()));

        $returnDescribe = $returnType->describe();

        if (0 || $error) echoPre('call of: '.simpleClassName(static::$className).'::'.$methodCall->name.'()  in: '.$this->getScopeDescription($scope).'  shall return: '.$returnDescribe.($returnDescribe==$origReturnDescribe ? ' (pass through)' : ' (was '.$origReturnDescribe.')'));
        return $returnType;
    }
614441
private function getCacheFile(\ReflectionClass $reflectionClass)
    {
        return sprintf('%s/%s/%s.php.cache', $this->kernel->getCacheDir(), Constants::CACHE_DIR, str_replace('\\', '_', $reflectionClass->getName()));
    }
1245414
public function SetReturnType(\Peg\Lib\Definitions\Element\ReturnType $return_type)
    {
        $return_type->overload =& $this;
        
        $this->return_type = $return_type;
        
        return $this;
    }
904933
public function getReturnType(): Type
    {
        if (! isset($this->returnType)) {
            $this->returnType = app(DefinitionNodeConverter::class)->toType(
                $this->field->type
            );
        }

        return $this->returnType;
    }
739998
public static function getReflectionCallableName(
        ReflectionFunctionAbstract $reflector
    ) {
        $class = $reflector instanceof ReflectionFunction
            ? $reflector->getClosureScopeClass()
            : $reflector->getDeclaringClass();
        if (is_null($class)) {
            return $reflector->getName();
        }
        return $class->getName() . '::' . $reflector->getName();
    }
1066979
private function getMethodReturnType(\ReflectionMethod $method)
    {
        if ( ! $method->hasReturnType()) {
            return '';
        }

        return ': ' . $this->formatType($method->getReturnType(), $method);
    }