Returns the fully qualified name of the type.
180280
public String getFullyQualifiedName() {
        StringBuilder sb = new StringBuilder();
        if (packageName != null && !packageName.isEmpty()) {
            sb.append(getPackageName()).append(".");
        }

        if (outerType != null) {
            sb.append(outerType.getName()).append(".");
        }
        sb.append(getName());

        return sb.toString();
    }
468346
public final String getName() {
        switch (type) {
            case ServletConfig:
                return servletConfig.getServletName();
            case FilterConfig:
                return filterConfig.getFilterName();
            case ServletContext:
                return servletContext.getServletContextName();
            default:
                throw new IllegalStateException();
        }
    }
1007618
protected static String toGoodTypeName(String typeName) {
    int lastDotPosition = typeName.lastIndexOf(".");
    if(lastDotPosition == -1) {
      return typeName;
    }
    else {
      return typeName.substring(lastDotPosition + 1);
    }
  }
732723
def get_type_name(type_name, sub_type=None):
    
    if type_name in ("string", "enum"):
        return "string"

    if type_name == "float":
        return "float64"

    if type_name == "boolean":
        return "bool"

    if type_name == "list":
        st = get_type_name(type_name=sub_type, sub_type=None) if sub_type else "interface{}"
        return "[]%s" % st

    if type_name == "integer":
        return "int"

    if type_name == "time":
        return "float64"

    return "interface{}"
248938
def qualified_name(cls):
    
    module = cls.__module__
    if module is None or module == str.__class__.__module__:
        return cls.__name__
    return module + '.' + cls.__name__
504857
public String getTypeGenericsSimple() {
        final String type = getType();
        if (type.contains("<")) {
            return type.substring(type.indexOf('<') + 1, type.length() - 1);
        }
        return "";
    }
542398
def full_name(self):
        """"""
        if self.prefix is not None:
            return '.'.join([self.prefix, self.member])
        return self.member
493143
def getTypename(cls):
        '''
        
        '''
        if cls is Event:
            return None
        else:
            for c in cls.__bases__:
                if issubclass(c, Event):
                    if c is Event:
                        return cls._getTypename()
                    else:
                        return c.getTypename()
908235
public final String getQualifiedName() {
        return null == owner ? name : owner + Symbol.DOT.getLiterals() + name;
    }
279700
function getTypeName(namespace, type) {
    let namespaceName = namespace.fullName;
    let finalName;
    for (let title of type.titles) {
        let name = titleToTypeName(namespaceName, title);
        if (finalName) {
            if (name[1]) {
                // An explicit type name, so make sure it isn't masking anything
                if (finalName[1] && name[0] !== finalName[0]) {
                    // Previous explicit name from another title is different
                    throw new Error(title + '\'s override to ' + name[0]
                        + ' would shadow explicit name of ' + finalName[0]);
                }
                // Otherwise take this name since it either is the same, or overrides
                // a non-explicit name
                finalName = name;
            }
            else if (!finalName[1] && name[0].length < finalName[0].length) {
                // Take the shorter of the generated names
                finalName = name;
            }
        }
        else {
            // First valid name
            finalName = name;
        }
    }
    if (finalName) {
        return finalName;
    }
    else {
        throw new Error('Unable to generate typename for ' + type.titles[0]);
    }
}
1345373
public static FullTypeSignature getTypeSignature(String typeSignatureString,
			boolean useInternalFormFullyQualifiedName) {
		String key;
		if (!useInternalFormFullyQualifiedName) {
			key = typeSignatureString.replace('.', '/')
					.replace('$', '.');
		} else {
			key = typeSignatureString;
		}

		// we always use the internal form as a key for cache
		FullTypeSignature typeSignature = typeSignatureCache
				.get(key);
		if (typeSignature == null) {
			ClassFileTypeSignatureParser typeSignatureParser = new ClassFileTypeSignatureParser(
					typeSignatureString);
			typeSignatureParser.setUseInternalFormFullyQualifiedName(useInternalFormFullyQualifiedName);
			typeSignature = typeSignatureParser.parseTypeSignature();
			typeSignatureCache.put(typeSignatureString, typeSignature);
		}
		return typeSignature;
	}
230168
protected String finalTypename(String typeName, String programContext) {
        String qualifiedName = qualifiedTypenameInternal(typeName, programContext);

        if (typedefs.containsKey(qualifiedName)) {
            String resolved = typedefs.get(qualifiedName);
            return finalTypename(resolved, programContext);
        }

        return qualifiedName;
    }
537671
public static String getQualifiedName(TypeMirror type) {
    switch (type.getKind()) {
      case DECLARED:
        return getQualifiedNameForTypeElement((TypeElement) ((DeclaredType) type).asElement());
      case TYPEVAR:
        return getQualifiedNameForElement(((TypeVariable) type).asElement());
      case INTERSECTION:
        return "&";
      case WILDCARD:
        return "?";
      default:
        throw new AssertionError("Unexpected type: " + type + " with kind: " + type.getKind());
    }
  }
104548
private String getTypeName( Type type ) {
        CheckArg.isNotNull(type, "type");
        if (type.isPrimitiveType()) {
            PrimitiveType primitiveType = (PrimitiveType)type;
            return primitiveType.getPrimitiveTypeCode().toString();
        }
        if (type.isSimpleType()) {
            SimpleType simpleType = (SimpleType)type;
            return JavaMetadataUtil.getName(simpleType.getName());
        }
        if (type.isParameterizedType()) {
            ParameterizedType parameterizedType = (ParameterizedType)type;
            return getTypeName(parameterizedType.getType());
        }
        if (type.isArrayType()) {
            ArrayType arrayType = (ArrayType)type;
            // the element type is never an array type
            Type elementType = arrayType.getElementType();
            if (elementType.isPrimitiveType()) {
                return ((PrimitiveType)elementType).getPrimitiveTypeCode().toString();

            }
            // can't be an array type
            if (elementType.isSimpleType()) {
                return JavaMetadataUtil.getName(((SimpleType)elementType).getName());
            }

        }
        return null;
    }
671401
def qualified_name(self):
        ''''''
        return '{0}.{1}#{2}'.format(self.module.name, self.enum.name, self.name)
1302900
def chpl_type_name(self):
        """"""
        if not self.objtype.endswith('method'):
            return ''
        elif self.objtype.startswith('iter'):
            return 'iterator'
        elif self.objtype == 'method':
            return 'method'
        else:
            return ''
54892
def type_name(self) -> T.Optional[str]:
        """"""
        return self.args[1] if len(self.args) > 1 else None