Returns the actual type arguments.
978400
public JType []getActualTypeArguments()
  {
    Type []rawArgs = _type.getActualTypeArguments();

    JType []args = new JType[rawArgs.length];
    for (int i = 0; i < args.length; i++) {
      Type type = rawArgs[i];

      if (type instanceof Class) {
        args[i] = _loader.forName(((Class) type).getName());
      }
      else if (type instanceof ParameterizedType)
        args[i] = new JTypeWrapper(_loader, (ParameterizedType) type);
      else {
        args[i] = _loader.forName("java.lang.Object");
        // jpa/0gg0
        // throw new IllegalStateException(type.toString());
      }
    }

    return args;
  }
459315
def types(self):
        
        output = set()
        for var in self.values():
            if var.has_value():
                output.update(var.types())
        return list(output)
671169
def args(self):
        """"""
        if self._args is None:
            parser = self._build_parser()
            self._args = parser.parse_args()
        return self._args
67237
public String getArgTypes()
    {
        StringBuffer sb = new StringBuffer();
        int i = 0;

        if ( _methodDecl == null || _methodDecl.getParameters() == null )
            return "";
        
        for (ParameterDeclaration paramDecl : _methodDecl.getParameters())
        {
            if (i++ != 0)
                sb.append(", ");

            TypeMirror paramType = paramDecl.getType();
            if (paramType == null)
                return "";

            //
            // Use the erasure here, because we only want the raw type, not the reference
            // type
            //
            sb.append(_ap.getAnnotationProcessorEnvironment().getTypeUtils().getErasure(paramType));
            sb.append(".class");
        }
        return sb.toString();
    }
520969
public static String getArgsTypeName(String[] argTypes) {
        if (argTypes != null) {
            return StringUtil.join(argTypes, ',');
        }
        return StringUtil.EMPTY;
    }
333564
def check_argument_type(dtype, kernel_argument, i):
    """"""
    types_map = {"uint8": ["uchar", "unsigned char", "uint8_t"],
                 "int8": ["char", "int8_t"],
                 "uint16": ["ushort", "unsigned short", "uint16_t"],
                 "int16": ["short", "int16_t"],
                 "uint32": ["uint", "unsigned int", "uint32_t"],
                 "int32": ["int", "int32_t"],   #discrepancy between OpenCL and C here, long may be 32bits in C
                 "uint64": ["ulong", "unsigned long", "uint64_t"],
                 "int64": ["long", "int64_t"],
                 "float16": ["half"],
                 "float32": ["float"],
                 "float64": ["double"]}
    if dtype in types_map:
        return any([substr in kernel_argument for substr in types_map[dtype]])
    else:
        return False
1230199
def _type_to_str(self, type):
        
        for key, val in self.TYPE_NAMES.items():
            if key == type:
                return val
433063
def get_arg_type_descriptors(self):
        

        if not self.is_method:
            return tuple()

        tp = _typeseq(self.get_descriptor())
        tp = _typeseq(tp[0][1:-1])

        return tp
20042
public static Class<?>[] getTypes( Object[] args )
    {
        if ( args == null )
            return Reflect.ZERO_TYPES;

        Class<?>[] types = new Class[ args.length ];

        for( int i=0; i < args.length; i++ )
            types[i] = getType(args[i]);

        return types;
    }
1211186
def getTypeStr(_type):
  
  """
  if isinstance(_type, CustomType):
    return str(_type)

  if hasattr(_type, '__name__'):
    return _type.__name__

  return ''
374869
def _py_ex_argtype(executable):
    
    result = []
    for p in executable.ordered_parameters:
        atypes = p.argtypes
        if atypes is not None:
            result.extend(p.argtypes)
        else:
            print(("No argtypes for: {}".format(p.definition())))

    if type(executable).__name__ == "Function":
        result.extend(executable.argtypes)        
            
    return result
1169785
public List<MethodParameter> getParametersOfType(Class<?> type) {

		Assert.notNull(type, "Type must not be null!");

		return getParameters().stream() //
				.filter(it -> it.getParameterType().equals(type)) //
				.collect(Collectors.toList());
	}
226354
List<String> getArgumentsType(ExecutableElement methodElement) {
		ExecutableType methodType = (ExecutableType) methodElement.asType();
		List<String> res = new ArrayList<>();
		for (TypeMirror argumentType : methodType.getParameterTypes()) {
			res.add(argumentType.toString());
		}
		return res;
	}
1208068
def _get_type_hints(func, args = None, res = None, infer_defaults = None):
    
    if args is None or res is None:
        args2, res2 = _get_types(func, util.is_classmethod(func),
                util.is_method(func), unspecified_type = type(NotImplemented),
                infer_defaults = infer_defaults)
        if args is None:
            args = args2
        if res is None:
            res = res2
    slf = 1 if util.is_method(func) else 0
    argNames = util.getargnames(util.getargspecs(util._actualfunc(func)))
    result = {}
    if not args is Any:
        prms = get_Tuple_params(args)
        for i in range(slf, len(argNames)):
            if not prms[i-slf] is type(NotImplemented):
                result[argNames[i]] = prms[i-slf]
    result['return'] = res
    return result
748782
def _get_types(type_):
    

    return list(
        itertools.chain.from_iterable(
            map(lambda x: TYPE_MAPPINGS[x].get(type_, []), TYPE_MAPPINGS)
        )
    )
1293095
def types(self, *args):
        
        return ', '.join(['{0}({1})'.format(type(arg).__name__, arg) for arg in args])
581798
private final Type getGenericType() {
        final Class<?> raw = getClass();
        final TypeVariable<?>[] typeParameters = raw.getTypeParameters();
        if (ArrayUtils.isEmpty(typeParameters)) {
            return raw;
        }
        final Type[] parameters = new Type[typeParameters.length];

        // use empty type variable map because we're relying on @BindTypeVariable functionality:
        final Map<TypeVariable<?>, Type> typeVariableMap = Collections.emptyMap();
        for (int i = 0; i < parameters.length; i++) {
            parameters[i] = Types.resolveAt(this, typeParameters[i], typeVariableMap);
        }
        return TypeUtils.parameterize(raw, parameters);
    }