org.eclipse.jdt.core.dom.QualifiedType Java Examples

private static boolean isQualifiedType(Type type) {
	if(type instanceof SimpleType) {
		SimpleType simpleType = (SimpleType)type;
		Name name = simpleType.getName();
		if(name instanceof QualifiedName) {
			return true;
		}
	}
	else if(type instanceof QualifiedType) {
		QualifiedType qualifiedType = (QualifiedType)type;
		Type qualifier = qualifiedType.getQualifier();
		return isQualifiedType(qualifier);
	}
	else if(type instanceof ArrayType) {
		ArrayType arrayType = (ArrayType)type;
		Type elementType = arrayType.getElementType();
		return isQualifiedType(elementType);
	}
	else if(type instanceof ParameterizedType) {
		ParameterizedType parameterizedType = (ParameterizedType)type;
		Type erasureType = parameterizedType.getType();
		return isQualifiedType(erasureType);
	}
	return false;
}
 

/**
 * For {@link Name} or {@link Type} nodes, returns the topmost {@link Type} node
 * that shares the same type binding as the given node.
 * 
 * @param node an ASTNode
 * @return the normalized {@link Type} node or the original node
 */
public static ASTNode getNormalizedNode(ASTNode node) {
	ASTNode current= node;
	// normalize name
	if (QualifiedName.NAME_PROPERTY.equals(current.getLocationInParent())) {
		current= current.getParent();
	}
	// normalize type
	if (QualifiedType.NAME_PROPERTY.equals(current.getLocationInParent())
			|| SimpleType.NAME_PROPERTY.equals(current.getLocationInParent())
			|| NameQualifiedType.NAME_PROPERTY.equals(current.getLocationInParent())) {
		current= current.getParent();
	}
	// normalize parameterized types
	if (ParameterizedType.TYPE_PROPERTY.equals(current.getLocationInParent())) {
		current= current.getParent();
	}
	return current;
}
 

/**
 * @return a String representation of 'type'. Handles qualified, simple and parameterized types.
 */
@Nullable
private String getNameOfType(Type type) {
  if (type instanceof QualifiedType) {
    return extractTypeNameWithoutGenerics((QualifiedType) type);
  }
  if (type instanceof SimpleType) {
    return ((SimpleType) type).getName().getFullyQualifiedName();
  }
  if (type instanceof ParameterizedType) {
    return getNameOfType(((ParameterizedType) type).getType());
  }
  return null;
}
 

private void handleType(Type type) {
	if (type instanceof PrimitiveType) {
		visit((PrimitiveType) type);
	} else if (type instanceof ArrayType) {
		visit((ArrayType) type);
	} else if (type instanceof SimpleType) {
		visit((SimpleType) type);
	} else if (type instanceof QualifiedType) {
		visit((QualifiedType) type);
	} else if (type instanceof ParameterizedType) {
		visit((ParameterizedType) type);
	} else if (type instanceof WildcardType) {
		visit((WildcardType) type);
	}
}
 

public boolean visit(QualifiedType type) {
	/*
	 * QualifiedType: Type . SimpleName
	 */
	activateDiffStyle(type);
	handleType(type.getQualifier());
	appendPeriod();
	handleExpression(type.getName());
	deactivateDiffStyle(type);
	return false;
}
 

private void handleType(Type type) {
	if (type instanceof PrimitiveType) {
		visit((PrimitiveType) type);
	} else if (type instanceof ArrayType) {
		visit((ArrayType) type);
	} else if (type instanceof SimpleType) {
		visit((SimpleType) type);
	} else if (type instanceof QualifiedType) {
		visit((QualifiedType) type);
	} else if (type instanceof ParameterizedType) {
		visit((ParameterizedType) type);
	} else if (type instanceof WildcardType) {
		visit((WildcardType) type);
	}
}
 

public boolean visit(QualifiedType node) {
	types.add(node.toString());
	if(current.getUserObject() != null) {
		AnonymousClassDeclarationObject anonymous = (AnonymousClassDeclarationObject)current.getUserObject();
		anonymous.getTypes().add(node.toString());
	}
	return false;
}
 

@Override
public boolean visit(final QualifiedType node) {
  node.getQualifier().accept(this);
  this.appendToBuffer(".");
  node.getName().accept(this);
  return false;
}
 

private static String getPrettyTypeName(Type type) {
    if (type.isArrayType()) {
        return getPrettyTypeName((ArrayType) type);
    } else if (type.isParameterizedType()) {
        return getPrettyTypeName((ParameterizedType) type);
    } else if (type.isPrimitiveType()) {
        return getPrettyTypeName((PrimitiveType) type);
    } else if (type.isQualifiedType()) {
        return getPrettyTypeName((QualifiedType) type);
    } else if (type.isSimpleType()) {
        return getPrettyTypeName((SimpleType) type);
    } else {
        return "";
    }
}
 

@Override
public void endVisit(QualifiedType node) {
	if (skipNode(node)) {
		return;
	}
	processSequential(node, node.getQualifier(), node.getName());
}
 

private TypeLiteral createBuilderClassReferenceLiteral(AST ast, CompilationUnitModificationDomain compilationUnitModificationDomain, TypeDeclaration builderType) {
    String originalClassName = compilationUnitModificationDomain.getOriginalType().getName().toString();
    String builderClassName = builderType.getName().toString();

    QualifiedType qualifiedType = ast.newQualifiedType(ast.newSimpleType(ast.newSimpleName(originalClassName)), ast.newSimpleName(builderClassName));

    TypeLiteral typeLiteral = ast.newTypeLiteral();
    typeLiteral.setType(qualifiedType);
    return typeLiteral;
}
 

@Test
public void testExtractTypeNameWithoutGenerics() {
  AST ast = AST.newAST(AST.JLS4);
  org.eclipse.jdt.core.dom.SimpleName entry = ast.newSimpleName("Entry");
  ParameterizedType map = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("Map")));
  map.typeArguments().add(ast.newSimpleType(ast.newSimpleName("Foo")));
  QualifiedType type = ast.newQualifiedType(map, entry);
  assertThat(type.toString()).isEqualTo("Map<Foo>.Entry");
  assertThat(ReferencedClassesParser.extractTypeNameWithoutGenerics(type)).isEqualTo("Map.Entry");
}
 

@Override
public boolean visit(QualifiedType node) {
  addType(
      node.resolveBinding(),
      extractClassNameFromQualifiedName(extractTypeNameWithoutGenerics(node)),
      node.getStartPosition());
  return true;
}
 

private static String getPrettyTypeName(QualifiedType type) {
    return type.resolveBinding().getQualifiedName();
}
 

@Override
public boolean visit(final QualifiedType node) {
	Assert.isNotNull(node);
	return false;
}
 

@Override
public void endVisit(QualifiedType node) {
	if (skipNode(node))
		return;
	processSequential(node, node.getQualifier(), node.getName());
}
 

@Override
public boolean visit(QualifiedType node) {
	if (node.subtreeMatch(fMatcher, fNodeToMatch))
		return matches(node);
	return super.visit(node);
}
 

@Override
public void endVisit(QualifiedType node) {
	endVisitNode(node);
}
 

@Override
public boolean visit(QualifiedType node) {
	return visitNode(node);
}
 

@Override
public boolean visit(QualifiedType node) {
	doVisitNode(node.getQualifier());
	visitAnnotations(node);
	return false;
}
 

private static void getFullyQualifiedName(Type type, StringBuffer buffer) {
	switch (type.getNodeType()) {
		case ASTNode.ARRAY_TYPE:
			ArrayType arrayType = (ArrayType) type;
			getFullyQualifiedName(arrayType.getElementType(), buffer);
			for (int i = 0, length = arrayType.getDimensions(); i < length; i++) {
				buffer.append('[');
				buffer.append(']');
			}
			break;
		case ASTNode.PARAMETERIZED_TYPE:
			ParameterizedType parameterizedType = (ParameterizedType) type;
			getFullyQualifiedName(parameterizedType.getType(), buffer);
			buffer.append('<');
			Iterator iterator = parameterizedType.typeArguments().iterator();
			boolean isFirst = true;
			while (iterator.hasNext()) {
				if (!isFirst)
					buffer.append(',');
				else
					isFirst = false;
				Type typeArgument = (Type) iterator.next();
				getFullyQualifiedName(typeArgument, buffer);
			}
			buffer.append('>');
			break;
		case ASTNode.PRIMITIVE_TYPE:
			buffer.append(((PrimitiveType) type).getPrimitiveTypeCode().toString());
			break;
		case ASTNode.QUALIFIED_TYPE:
			buffer.append(((QualifiedType) type).getName().getFullyQualifiedName());
			break;
		case ASTNode.SIMPLE_TYPE:
			buffer.append(((SimpleType) type).getName().getFullyQualifiedName());
			break;
		case ASTNode.WILDCARD_TYPE:
			buffer.append('?');
			WildcardType wildcardType = (WildcardType) type;
			Type bound = wildcardType.getBound();
			if (bound == null) return;
			if (wildcardType.isUpperBound()) {
				buffer.append(" extends "); //$NON-NLS-1$
			} else {
				buffer.append(" super "); //$NON-NLS-1$
			}
			getFullyQualifiedName(bound, buffer);
			break;
	}
}
 

public boolean visit(QualifiedType type) {
	handleType(type.getQualifier());
	handleExpression(type.getName());
	return false;
}