Java Code Examples for org.eclipse.jdt.core.Signature#C_STAR

/**
 * Returns the lower bound of a type signature. Returns the null type
 * signature if <code>signature</code> is a wildcard or upper bound (<code>? extends T</code>);
 * returns the signature of the type <code>T</code> of a lower bound (<code>? super T</code>)
 * or <code>signature</code> itself if it is not a bound signature.
 *
 * @param signature the signature
 * @return the lower bound signature of <code>signature</code>
 */
public static char[] getLowerBound(char[] signature) {
	if (signature.length < 1)
		return signature;

	if (signature.length == 1 && signature[0] == Signature.C_STAR)
		return signature;

	int superIndex= indexOf(signature, Signature.C_EXTENDS);
	if (superIndex == 0)
		return NULL_TYPE_SIGNATURE_ARRAY;

	if (superIndex != -1) {
		char afterSuper= signature[superIndex + 1];
		if (afterSuper == Signature.C_STAR || afterSuper == Signature.C_EXTENDS)
			// impossible captured type
			return NULL_TYPE_SIGNATURE_ARRAY;
	}

	char[][] typeArguments= Signature.getTypeArguments(signature);
	for (int i= 0; i < typeArguments.length; i++)
		if (Arrays.equals(typeArguments[i], NULL_TYPE_SIGNATURE_ARRAY))
			return NULL_TYPE_SIGNATURE_ARRAY;

	if (signature[0] == Signature.C_SUPER) {
		char[] type= new char[signature.length - 1];
		System.arraycopy(signature, 1, type, 0, signature.length - 1);
		return type;
	}

	return signature;
}
 

protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags) {
	int sigKind= Signature.getTypeSignatureKind(typeSig);
	switch (sigKind) {
	case Signature.BASE_TYPE_SIGNATURE:
		fBuilder.append(Signature.toString(typeSig));
		break;
	case Signature.ARRAY_TYPE_SIGNATURE:
		appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags);
		for (int dim= Signature.getArrayCount(typeSig); dim > 0; dim--) {
			fBuilder.append('[').append(']');
		}
		break;
	case Signature.CLASS_TYPE_SIGNATURE:
		String baseType= getSimpleTypeName(enclosingElement, typeSig);
		fBuilder.append(baseType);

		String[] typeArguments= Signature.getTypeArguments(typeSig);
		appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags);
		break;
	case Signature.TYPE_VARIABLE_SIGNATURE:
		fBuilder.append(getSimpleTypeName(enclosingElement, typeSig));
		break;
	case Signature.WILDCARD_TYPE_SIGNATURE:
		char ch= typeSig.charAt(0);
		if (ch == Signature.C_STAR) { //workaround for bug 85713
			fBuilder.append('?');
		} else {
			if (ch == Signature.C_EXTENDS) {
				fBuilder.append("? extends "); //$NON-NLS-1$
				appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
			} else if (ch == Signature.C_SUPER) {
				fBuilder.append("? super "); //$NON-NLS-1$
				appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
			}
		}
		break;
	case Signature.CAPTURE_TYPE_SIGNATURE:
		appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
		break;
	case Signature.INTERSECTION_TYPE_SIGNATURE:
		String[] typeBounds= Signature.getIntersectionTypeBounds(typeSig);
		appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags);
		break;
	default:
		// unknown
	}
}
 

protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags) {
	int sigKind= Signature.getTypeSignatureKind(typeSig);
	switch (sigKind) {
		case Signature.BASE_TYPE_SIGNATURE:
			fBuffer.append(Signature.toString(typeSig));
			break;
		case Signature.ARRAY_TYPE_SIGNATURE:
			appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags);
			for (int dim= Signature.getArrayCount(typeSig); dim > 0; dim--) {
				fBuffer.append('[').append(']');
			}
			break;
		case Signature.CLASS_TYPE_SIGNATURE:
			String baseType= getSimpleTypeName(enclosingElement, typeSig);
			fBuffer.append(baseType);

			String[] typeArguments= Signature.getTypeArguments(typeSig);
			appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags);
			break;
		case Signature.TYPE_VARIABLE_SIGNATURE:
			fBuffer.append(getSimpleTypeName(enclosingElement, typeSig));
			break;
		case Signature.WILDCARD_TYPE_SIGNATURE:
			char ch= typeSig.charAt(0);
			if (ch == Signature.C_STAR) { //workaround for bug 85713
				fBuffer.append('?');
			} else {
				if (ch == Signature.C_EXTENDS) {
					fBuffer.append("? extends "); //$NON-NLS-1$
					appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
				} else if (ch == Signature.C_SUPER) {
					fBuffer.append("? super "); //$NON-NLS-1$
					appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
				}
			}
			break;
		case Signature.CAPTURE_TYPE_SIGNATURE:
			appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
			break;
		case Signature.INTERSECTION_TYPE_SIGNATURE:
			String[] typeBounds= Signature.getIntersectionTypeBounds(typeSig);
			appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags);
			break;
		default:
			// unknown
	}
}
 

/**
 * Adds a new import to the rewriter's record and returns a {@link Type} node that can be used
 * in the code as a reference to the type. The type binding can be an array binding, type variable or wildcard.
 * If the binding is a generic type, the type parameters are ignored. For parameterized types, also the type
 * arguments are processed and imports added if necessary. Anonymous types inside type arguments are normalized to their base type, wildcard
 * of wildcards are ignored.
 * 	<p>
	 * No imports are added for types that are already known. If a import for a type is recorded to be removed, this record is discarded instead.
 * </p>
 * <p>
 * The content of the compilation unit itself is actually not modified
 * in any way by this method; rather, the rewriter just records that a new import has been added.
 * </p>
 * @param typeSig the signature of the type to be added.
 * @param ast the AST to create the returned type for.
 * @param context an optional context that knows about types visible in the current scope or <code>null</code>
 * to use the default context only using the available imports.
 * @return a type node for the given type signature. Type names are simple names if an import could be used,
 * or else qualified names if an import conflict prevented an import.
 */
public Type addImportFromSignature(String typeSig, AST ast, ImportRewriteContext context) {
	if (typeSig == null || typeSig.length() == 0) {
		throw new IllegalArgumentException("Invalid type signature: empty or null"); //$NON-NLS-1$
	}
	int sigKind= Signature.getTypeSignatureKind(typeSig);
	switch (sigKind) {
		case Signature.BASE_TYPE_SIGNATURE:
			return ast.newPrimitiveType(PrimitiveType.toCode(Signature.toString(typeSig)));
		case Signature.ARRAY_TYPE_SIGNATURE:
			Type elementType= addImportFromSignature(Signature.getElementType(typeSig), ast, context);
			return ast.newArrayType(elementType, Signature.getArrayCount(typeSig));
		case Signature.CLASS_TYPE_SIGNATURE:
			String erasureSig= Signature.getTypeErasure(typeSig);

			String erasureName= Signature.toString(erasureSig);
			if (erasureSig.charAt(0) == Signature.C_RESOLVED) {
				erasureName= internalAddImport(erasureName, context);
			}
			Type baseType= ast.newSimpleType(ast.newName(erasureName));
			String[] typeArguments= Signature.getTypeArguments(typeSig);
			if (typeArguments.length > 0) {
				ParameterizedType type= ast.newParameterizedType(baseType);
				List argNodes= type.typeArguments();
				for (int i= 0; i < typeArguments.length; i++) {
					String curr= typeArguments[i];
					if (containsNestedCapture(curr)) { // see bug 103044
						argNodes.add(ast.newWildcardType());
					} else {
						argNodes.add(addImportFromSignature(curr, ast, context));
					}
				}
				return type;
			}
			return baseType;
		case Signature.TYPE_VARIABLE_SIGNATURE:
			return ast.newSimpleType(ast.newSimpleName(Signature.toString(typeSig)));
		case Signature.WILDCARD_TYPE_SIGNATURE:
			WildcardType wildcardType= ast.newWildcardType();
			char ch= typeSig.charAt(0);
			if (ch != Signature.C_STAR) {
				Type bound= addImportFromSignature(typeSig.substring(1), ast, context);
				wildcardType.setBound(bound, ch == Signature.C_EXTENDS);
			}
			return wildcardType;
		case Signature.CAPTURE_TYPE_SIGNATURE:
			return addImportFromSignature(typeSig.substring(1), ast, context);
		default:
			throw new IllegalArgumentException("Unknown type signature kind: " + typeSig); //$NON-NLS-1$
	}
}
 

private Type createType(String typeSig, AST ast) {
	int sigKind = Signature.getTypeSignatureKind(typeSig);
       switch (sigKind) {
           case Signature.BASE_TYPE_SIGNATURE:
               return ast.newPrimitiveType(PrimitiveType.toCode(Signature.toString(typeSig)));
           case Signature.ARRAY_TYPE_SIGNATURE:
               Type elementType = createType(Signature.getElementType(typeSig), ast);
               return ast.newArrayType(elementType, Signature.getArrayCount(typeSig));
           case Signature.CLASS_TYPE_SIGNATURE:
               String erasureSig = Signature.getTypeErasure(typeSig);

               String erasureName = Signature.toString(erasureSig);
               if (erasureSig.charAt(0) == Signature.C_RESOLVED) {
                   erasureName = addImport(erasureName);
               }
               
               Type baseType= ast.newSimpleType(ast.newName(erasureName));
               String[] typeArguments = Signature.getTypeArguments(typeSig);
               if (typeArguments.length > 0) {
                   ParameterizedType type = ast.newParameterizedType(baseType);
                   List argNodes = type.typeArguments();
                   for (int i = 0; i < typeArguments.length; i++) {
                       String curr = typeArguments[i];
                       if (containsNestedCapture(curr)) {
                           argNodes.add(ast.newWildcardType());
                       } else {
                           argNodes.add(createType(curr, ast));
                       }
                   }
                   return type;
               }
               return baseType;
           case Signature.TYPE_VARIABLE_SIGNATURE:
               return ast.newSimpleType(ast.newSimpleName(Signature.toString(typeSig)));
           case Signature.WILDCARD_TYPE_SIGNATURE:
               WildcardType wildcardType= ast.newWildcardType();
               char ch = typeSig.charAt(0);
               if (ch != Signature.C_STAR) {
                   Type bound= createType(typeSig.substring(1), ast);
                   wildcardType.setBound(bound, ch == Signature.C_EXTENDS);
               }
               return wildcardType;
           case Signature.CAPTURE_TYPE_SIGNATURE:
               return createType(typeSig.substring(1), ast);
       }
       
       return ast.newSimpleType(ast.newName("java.lang.Object"));
}