Returns the method's return type
187024
public TypeDescription getReturnType() {
        if (mReturnType == null) {
            mReturnType = 
                getTeaToolsUtils().createTypeDescription(
                                          getMethod().getReturnType());
        }

        return mReturnType;
    }
367308
private static Method getMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        try {
            return clazz.getMethod(name, paramTypes);
        } catch (NoSuchMethodException e) {
            return getMethod0(clazz, name, paramTypes);
        }
    }
1140328
public static String returnValue(CtBehavior method) throws NotFoundException {

        String returnValue = "";
        if (methodReturnsValue(method)) {
            returnValue = " returns: \" + $_ + \".";
        }
        return returnValue;
    }
120928
private boolean isValidReturnValueType(ExpressionTree tree, VisitorState state) {
    Type returnType = null;
    if (tree instanceof MethodInvocationTree) {
      returnType = getReturnType(((JCMethodInvocation) tree).getMethodSelect());
    } else if (tree instanceof MemberReferenceTree) {
      // Get the return type of the target referenced interface
      returnType =
          state.getTypes().findDescriptorType(((JCMemberReference) tree).type).getReturnType();
    }
    if (returnType != null) {
      return capturedTypeAllowed(returnType, state);
    }
    return true;
  }
1315083
function getIsTypeMethod(name) {
    const types = ['number', 'boolean', 'function', 'Function', 'string', 'object', 'undefined', 'Date', 'Array', 'Error', 'Element']
    return _.includes(types, name) ? `is${_.capitalize(name)}` : null
}
1079668
function Return(type) {
    // 
    return function (target, propertyKey, descriptor) {
        if (!target.methodReturns) {
            target.methodReturns = {};
        }
        target.methodReturns[propertyKey] = type;
    };
}
19140
def check_return_types(self, method):
        ''''''
        mn = method.__name__
        retanno = method.__annotations__.get('return', None)
        # Take a look at the syntax
        if not retanno:
            return ['Missing return types for method "{}"'.format(mn)]
        if not isinstance(retanno, (list, tuple)):
            msg = 'Return annotation for method "{}" not tuple nor list'
            return [msg.format(mn)]
        if (any(map(lambda t: not isinstance(t, (list, tuple)), retanno)) or
                any(map(lambda t: not (2 <= len(t) <= 3), retanno))):
            msg = ('Return values series for "{}" should be composed of '
                   '2 or 3-items tuples (code, msg, type).')
            return [msg.format(mn)]
        errors = []
        # Take a look at the codes
        declared = set([t[0] for t in retanno])
        actual = set(int(s)
                     for s in HTTP_STATUSES_REGEX.findall(method.source))
        if declared != actual:
            if declared.issubset(actual):
                msg = 'Method {} returns undeclared codes: {}.'
                errors.append(msg.format(mn, actual - declared))
            elif actual.issubset(declared):
                msg = 'Method {} declares codes {} that are never used.'
                errors.append(msg.format(mn, declared - actual))
            else:
                msg = 'Declared {} and Used {} codes mismatch.'
                errors.append(msg.format(declared, actual))
        # Take a look at the types
        ret_with_types = filter(lambda t: len(t) == 3, retanno)
        msg = 'Method {} return type for code {} must be class (not instance).'
        msg_mod = 'Method {} return type for code {} must subclass from Model.'
        for code, _, type_ in ret_with_types:
            try:
                if Model not in type_.__bases__:
                    errors.append(msg_mod.format(mn, code))
            except AttributeError:
                errors.append(msg.format(mn, code))
        return errors
604512
def get_types(func):
    
    return _get_types(func, util.is_classmethod(func), util.is_method(func))
837778
def get_method(self, node):
        '''
        '''
        methods = self._methods
        for methodname in self.get_methodnames(node):
            if methodname in methods:
                return methods[methodname]
            else:
                cls = self.__class__
                method = getattr(cls, methodname, None)
                if method is not None:
                    methods[methodname] = method
                    return method
1206938
function getReturn(spec_c, details, method, parent) {
  var retType = getType(getText(spec_c, 'type'), parent);
  var retDescription = (details ? getText(details, 'description') : '');
  return ((retType == 'void') ? {} : {
    type: retType,
    description: retDescription
  });
}
546124
public static String getMethodDesc(Method method) {
        Assert.notNull(method);
        return getDesc(method.getReturnType(), method.getParameterTypes());
    }
199567
def return_type(self, return_type):
        """"""

        return_type = _ensure_unicode(return_type)

        # We perform this check after the initialization to avoid errors
        # in test tools that show the object with repr().
        if return_type not in ALL_CIMTYPES:
            raise ValueError(
                _format("Invalid CIM type: {0}", return_type))
        if return_type == 'reference':
            raise ValueError("Method cannot have a reference return type")

        # pylint: disable=attribute-defined-outside-init
        self._return_type = return_type
827088
function getTypeFromContext (context) {
  if (!context.method.returns) return undefined

  const returns = [].concat(context.method.returns)
  for (var i = 0, l = returns.length; i < l; i++) {
    if (typeof returns[i] !== 'object' || returns[i].root !== true) continue
    return returns[i].type
  }
}
1000669
def get_kind(self):
        
        scope = self.parent.get_scope()
        if isinstance(self.parent, PyClass):
            for decorator in self.decorators:
                pyname = rope.base.evaluate.eval_node(scope, decorator)
                if pyname == rope.base.builtins.builtins['staticmethod']:
                    return 'staticmethod'
                if pyname == rope.base.builtins.builtins['classmethod']:
                    return 'classmethod'
            return 'method'
        return 'function'
1115804
public static void doReturn(MethodVisitor mv, ClassNode returnType) {
        if (returnType == ClassHelper.double_TYPE) {
            mv.visitInsn(DRETURN);
        } else if (returnType == ClassHelper.float_TYPE) {
            mv.visitInsn(FRETURN);
        } else if (returnType == ClassHelper.long_TYPE) {
            mv.visitInsn(LRETURN);
        } else if (
                returnType == ClassHelper.boolean_TYPE
                        || returnType == ClassHelper.char_TYPE
                        || returnType == ClassHelper.byte_TYPE
                        || returnType == ClassHelper.int_TYPE
                        || returnType == ClassHelper.short_TYPE) {
            //byte,short,boolean,int are all IRETURN
            mv.visitInsn(IRETURN);
        } else if (returnType == ClassHelper.VOID_TYPE) {
            mv.visitInsn(RETURN);
        } else {
            mv.visitInsn(ARETURN);
        }

    }
53660
def get_method(self, method_name, default=None):
        
        for method in self.methods:
            if method.name == method_name:
                return method
        return default
714408
public Method getMethod(Class<?> returnType, String name, Class<?>... paramTypes) {
        final Map<ParamList, Map<Class<?>, Method>> nameMap = methods.get(name);
        if (nameMap == null) {
            return null;
        }
        final Map<Class<?>, Method> paramsMap = nameMap.get(createParamList(paramTypes));
        if (paramsMap == null) {
            return null;
        }
        return paramsMap.get(returnType);
    }