下面列出了org.eclipse.jdt.core.dom.TypeDeclaration#getSuperclassType ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public boolean visit(TypeDeclaration decl) {
if (decl.getName().toString().equals(seqDiagramName)) {
superClass = null;
Type sc = decl.getSuperclassType();
if (sc != null) {
String scName = sc.resolveBinding().getQualifiedName().toString();
if (!scName.equals("hu.elte.txtuml.api.model.seqdiag.Interaction")
&& !scName.equals("hu.elte.txtuml.api.model.seqdiag.SequenceDiagram")) {
superClass = sc;
}
}
return true;
}
return false;
}
public static VariableDeclaration findFieldDeclaration(AbstractVariable variable, TypeDeclaration typeDeclaration) {
for(FieldDeclaration fieldDeclaration : typeDeclaration.getFields()) {
List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
for(VariableDeclarationFragment fragment : fragments) {
if(variable.getVariableBindingKey().equals(fragment.resolveBinding().getKey())) {
return fragment;
}
}
}
//fragment was not found in typeDeclaration
Type superclassType = typeDeclaration.getSuperclassType();
if(superclassType != null) {
String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
SystemObject system = ASTReader.getSystemObject();
ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
if(superclassObject != null) {
AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
if(superclassTypeDeclaration instanceof TypeDeclaration) {
return findFieldDeclaration(variable, (TypeDeclaration)superclassTypeDeclaration);
}
}
}
return null;
}
public static MethodDeclaration findGetterDeclarationForField(VariableDeclaration variableDeclaration, TypeDeclaration typeDeclaration) {
for(MethodDeclaration methodDeclaration : typeDeclaration.getMethods()) {
SimpleName simpleName = MethodDeclarationUtility.isGetter(methodDeclaration);
if(simpleName != null && variableDeclaration.resolveBinding().isEqualTo(simpleName.resolveBinding())) {
return methodDeclaration;
}
}
//fragment was not found in typeDeclaration
Type superclassType = typeDeclaration.getSuperclassType();
if(superclassType != null) {
String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
SystemObject system = ASTReader.getSystemObject();
ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
if(superclassObject != null) {
AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
if(superclassTypeDeclaration instanceof TypeDeclaration) {
return findGetterDeclarationForField(variableDeclaration, (TypeDeclaration)superclassTypeDeclaration);
}
}
}
return null;
}
public static TypeDeclaration findDeclaringTypeDeclaration(IVariableBinding variableBinding, TypeDeclaration typeDeclaration) {
if(typeDeclaration.resolveBinding().isEqualTo(variableBinding.getDeclaringClass())) {
return typeDeclaration;
}
//fragment was not found in typeDeclaration
Type superclassType = typeDeclaration.getSuperclassType();
if(superclassType != null) {
String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
SystemObject system = ASTReader.getSystemObject();
ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
if(superclassObject != null) {
AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
if(superclassTypeDeclaration instanceof TypeDeclaration) {
return findDeclaringTypeDeclaration(variableBinding, (TypeDeclaration)superclassTypeDeclaration);
}
}
}
return null;
}
public static TypeDeclaration findDeclaringTypeDeclaration(IMethodBinding methodBinding, TypeDeclaration typeDeclaration) {
if(typeDeclaration.resolveBinding().isEqualTo(methodBinding.getDeclaringClass())) {
return typeDeclaration;
}
//method was not found in typeDeclaration
Type superclassType = typeDeclaration.getSuperclassType();
if(superclassType != null) {
String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
SystemObject system = ASTReader.getSystemObject();
ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
if(superclassObject != null) {
AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
if(superclassTypeDeclaration instanceof TypeDeclaration) {
return findDeclaringTypeDeclaration(methodBinding, (TypeDeclaration)superclassTypeDeclaration);
}
}
}
return null;
}
@Override
public boolean visit(TypeDeclaration node) {
AbstractClass clazz = new AbstractClass();
if (node.getSuperclassType() != null) {
ITypeBinding bind = node.getSuperclassType().resolveBinding();
clazz.setSuperClass(bind.getQualifiedName());
}
clazz.setInterface(node.isInterface());
if (packageName != null) {
clazz.setName(packageName+'.'+node.getName().getFullyQualifiedName());
} else {
clazz.setName(node.getName().getFullyQualifiedName());
}
TypeVisitor visitor = new TypeVisitor();
node.accept(visitor);
clazz.setMethods(visitor.getMethods());
clazz.setStartPosition(node.getStartPosition());
clazz.setEndPosition(node.getStartPosition() + node.getLength() - 1);
clazz.setFields(visitor.getFields());
types.add(clazz);
return true;
}
public boolean visit(TypeDeclaration node) {
Pair<String, String> clazzAndMethodName = NodeUtils.getTypeDecAndMethodDec(node.getName());
String clazz = clazzAndMethodName.getFirst();
AST ast = AST.newAST(AST.JLS8);
Type type = ast.newSimpleType(ast.newSimpleName(clazz));
ProjectInfo.addFieldType(clazz, "THIS", type);
Type suType = node.getSuperclassType();
if(suType != null){
ProjectInfo.addFieldType(clazz, "SUPER", suType);
ProjectInfo.addSuperClass(clazz, suType.toString());
}
List<Object> sInterfaces = node.superInterfaceTypes();
if(sInterfaces != null){
for(Object object : sInterfaces){
if(object instanceof Type){
Type interfaceType = (Type) object;
ProjectInfo.addSuperInterface(clazz, interfaceType.toString());
}
}
}
FieldDeclaration fields[] = node.getFields();
for (FieldDeclaration f : fields) {
for (Object o : f.fragments()) {
VariableDeclarationFragment vdf = (VariableDeclarationFragment) o;
Type tmpType = f.getType();
if(vdf.getExtraDimensions() > 0){
tmpType = ast.newArrayType((Type) ASTNode.copySubtree(ast, tmpType), vdf.getExtraDimensions());
}
ProjectInfo.addFieldType(clazz, vdf.getName().toString(), tmpType);
}
}
return true;
}
private boolean visitClass(TypeDeclaration node) {
ClassInfo classInfo = new ClassInfo();
classInfo.name = node.getName().getFullyQualifiedName();
classInfo.fullName = NameResolver.getFullName(node);
classInfo.visibility = getVisibility(node);
classInfo.isAbstract = isAbstract(node);
classInfo.isFinal = isFinal(node);
classInfo.superClassType = node.getSuperclassType() == null ? "java.lang.Object" : NameResolver.getFullName(node.getSuperclassType());
List<Type> superInterfaceList = node.superInterfaceTypes();
for (Type superInterface : superInterfaceList)
classInfo.superInterfaceTypeList.add(NameResolver.getFullName(superInterface));
if (node.getJavadoc() != null)
classInfo.comment = sourceContent.substring(node.getJavadoc().getStartPosition(), node.getJavadoc().getStartPosition() + node.getJavadoc().getLength());
classInfo.content = sourceContent.substring(node.getStartPosition(), node.getStartPosition() + node.getLength());
elementInfoPool.classInfoMap.put(classInfo.fullName, classInfo);
MethodDeclaration[] methodDeclarations = node.getMethods();
for (MethodDeclaration methodDeclaration : methodDeclarations) {
MethodInfo methodInfo = createMethodInfo(methodDeclaration, classInfo.fullName);
elementInfoPool.methodInfoMap.put(methodInfo.hashName(), methodInfo);
}
FieldDeclaration[] fieldDeclarations = node.getFields();
for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
List<FieldInfo> fieldInfos = createFieldInfos(fieldDeclaration, classInfo.fullName);
for (FieldInfo fieldInfo : fieldInfos)
elementInfoPool.fieldInfoMap.put(fieldInfo.hashName(), fieldInfo);
}
return true;
}
/**
* Creates a new type signature of a subtype.
*
* @param subRewrite
* the compilation unit rewrite of a subtype
* @param declaration
* the type declaration of a subtype
* @param extractedType
* the extracted super type
* @param extractedBinding
* the binding of the extracted super type
* @param monitor
* the progress monitor to use
* @throws JavaModelException
* if the type parameters cannot be retrieved
*/
protected final void createTypeSignature(final CompilationUnitRewrite subRewrite, final AbstractTypeDeclaration declaration, final IType extractedType, final ITypeBinding extractedBinding, final IProgressMonitor monitor) throws JavaModelException {
Assert.isNotNull(subRewrite);
Assert.isNotNull(declaration);
Assert.isNotNull(extractedType);
Assert.isNotNull(monitor);
try {
monitor.beginTask(RefactoringCoreMessages.ExtractSupertypeProcessor_preparing, 10);
final AST ast= subRewrite.getAST();
Type type= null;
if (extractedBinding != null) {
type= subRewrite.getImportRewrite().addImport(extractedBinding, ast);
} else {
subRewrite.getImportRewrite().addImport(extractedType.getFullyQualifiedName('.'));
type= ast.newSimpleType(ast.newSimpleName(extractedType.getElementName()));
}
subRewrite.getImportRemover().registerAddedImport(extractedType.getFullyQualifiedName('.'));
if (type != null) {
final ITypeParameter[] parameters= extractedType.getTypeParameters();
if (parameters.length > 0) {
final ParameterizedType parameterized= ast.newParameterizedType(type);
for (int index= 0; index < parameters.length; index++)
parameterized.typeArguments().add(ast.newSimpleType(ast.newSimpleName(parameters[index].getElementName())));
type= parameterized;
}
}
final ASTRewrite rewriter= subRewrite.getASTRewrite();
if (type != null && declaration instanceof TypeDeclaration) {
final TypeDeclaration extended= (TypeDeclaration) declaration;
final Type superClass= extended.getSuperclassType();
if (superClass != null) {
rewriter.replace(superClass, type, subRewrite.createCategorizedGroupDescription(RefactoringCoreMessages.ExtractSupertypeProcessor_add_supertype, SET_EXTRACT_SUPERTYPE));
subRewrite.getImportRemover().registerRemovedNode(superClass);
} else
rewriter.set(extended, TypeDeclaration.SUPERCLASS_TYPE_PROPERTY, type, subRewrite.createCategorizedGroupDescription(RefactoringCoreMessages.ExtractSupertypeProcessor_add_supertype, SET_EXTRACT_SUPERTYPE));
}
} finally {
monitor.done();
}
}
/**
* Creates the type signature of the extracted supertype.
*
* @param targetRewrite
* the target compilation unit rewrite
* @param superType
* the super type, or <code>null</code> if no super type (ie.
* <code>java.lang.Object</code>) is available
* @param declaringDeclaration
* the declaration of the declaring type
* @param targetDeclaration
* the type declaration of the target type
*/
protected final void createTypeSignature(final CompilationUnitRewrite targetRewrite, final IType superType, final AbstractTypeDeclaration declaringDeclaration, final AbstractTypeDeclaration targetDeclaration) {
Assert.isNotNull(targetRewrite);
Assert.isNotNull(declaringDeclaration);
Assert.isNotNull(targetDeclaration);
if (declaringDeclaration instanceof TypeDeclaration) {
final TypeDeclaration declaration= (TypeDeclaration) declaringDeclaration;
final Type superclassType= declaration.getSuperclassType();
if (superclassType != null) {
Type type= null;
final ITypeBinding binding= superclassType.resolveBinding();
if (binding != null) {
type= targetRewrite.getImportRewrite().addImport(binding, targetRewrite.getAST());
targetRewrite.getImportRemover().registerAddedImports(type);
}
if (type != null && targetDeclaration instanceof TypeDeclaration) {
final TypeDeclaration extended= (TypeDeclaration) targetDeclaration;
final Type targetSuperType= extended.getSuperclassType();
if (targetSuperType != null) {
targetRewrite.getASTRewrite().replace(targetSuperType, type, null);
} else {
targetRewrite.getASTRewrite().set(extended, TypeDeclaration.SUPERCLASS_TYPE_PROPERTY, type, null);
}
}
}
}
}
public static ClassBean parse(TypeDeclaration pClassNode) {
int numberOfGetterOrSetter = 0;
// Instantiate the bean
ClassBean classBean = new ClassBean();
if (pClassNode.getSuperclassType() != null) {
classBean.setSuperclass(pClassNode.getSuperclassType().toString());
} else {
classBean.setSuperclass(null);
}
// Set the name
classBean.setName(pClassNode.getName().toString());
// Get the instance variable nodes
Collection<FieldDeclaration> instanceVariableNodes = new ArrayList<>();
pClassNode.accept(new InstanceVariableVisitor(instanceVariableNodes));
classBean.setTextContent(pClassNode.toString());
Pattern newLine = Pattern.compile("\n");
String[] lines = newLine.split(pClassNode.toString());
classBean.setLOC(lines.length);
// Get the instance variable beans from the instance variable nodes
Collection<InstanceVariableBean> instanceVariableBeans = new ArrayList<>();
for (FieldDeclaration instanceVariableNode : instanceVariableNodes) {
instanceVariableBeans.add(InstanceVariableParser.parse(instanceVariableNode));
}
// Set the collection of instance variables
classBean.setInstanceVariables(instanceVariableBeans);
// Get the method nodes
Collection<MethodDeclaration> methodNodes = new ArrayList<>();
pClassNode.accept(new MethodVisitor(methodNodes));
// Get the method beans from the method nodes
Collection<MethodBean> methodBeans = new ArrayList<>();
for (MethodDeclaration methodNode : methodNodes) {
if ((methodNode.getName().toString().contains("get") || (methodNode.getName().toString().contains("set")))) {
if (methodNode.parameters().isEmpty()) {
numberOfGetterOrSetter++;
}
}
methodBeans.add(MethodParser.parse(methodNode, instanceVariableBeans));
}
classBean.setNumberOfGetterAndSetter(numberOfGetterOrSetter);
// Iterate over the collection of methods
for (MethodBean classMethod : methodBeans) {
// Instantiate a collection of class-defined invocations
Collection<MethodBean> definedInvocations = new ArrayList<>();
// Get the method invocations
Collection<MethodBean> classMethodInvocations = classMethod.getMethodCalls();
// Iterate over the collection of method invocations
for (MethodBean classMethodInvocation : classMethodInvocations) {
definedInvocations.add(classMethodInvocation);
}
// Set the class-defined invocations
classMethod.setMethodCalls(definedInvocations);
}
// Set the collection of methods
classBean.setMethods(methodBeans);
return classBean;
}
public static ClassBean parse(TypeDeclaration pClassNode, String belongingPackage, List<String> imports) {
int numberOfGetterOrSetter = 0;
// Instantiate the bean
ClassBean classBean = new ClassBean();
if (pClassNode.getSuperclassType() != null) {
classBean.setSuperclass(pClassNode.getSuperclassType().toString());
} else {
classBean.setSuperclass(null);
}
// Set the name
classBean.setName(pClassNode.getName().toString());
classBean.setImports(imports);
classBean.setBelongingPackage(belongingPackage);
// Get the instance variable nodes
Collection<FieldDeclaration> instanceVariableNodes = new ArrayList<>();
pClassNode.accept(new InstanceVariableVisitor(instanceVariableNodes));
classBean.setTextContent(pClassNode.toString());
Pattern newLine = Pattern.compile("\n");
String[] lines = newLine.split(pClassNode.toString());
classBean.setLOC(lines.length);
// Get the instance variable beans from the instance variable nodes
Collection<InstanceVariableBean> instanceVariableBeans = new ArrayList<>();
for (FieldDeclaration instanceVariableNode : instanceVariableNodes) {
instanceVariableBeans.add(InstanceVariableParser.parse(instanceVariableNode));
}
// Set the collection of instance variables
classBean.setInstanceVariables(instanceVariableBeans);
// Get the method nodes
Collection<MethodDeclaration> methodNodes = new ArrayList<>();
pClassNode.accept(new MethodVisitor(methodNodes));
// Get the method beans from the method nodes
Collection<MethodBean> methodBeans = new ArrayList<>();
for (MethodDeclaration methodNode : methodNodes) {
if ((methodNode.getName().toString().contains("get") || (methodNode.getName().toString().contains("set")))) {
if (methodNode.parameters().isEmpty()) {
numberOfGetterOrSetter++;
}
}
methodBeans.add(MethodParser.parse(methodNode, instanceVariableBeans));
}
classBean.setNumberOfGetterAndSetter(numberOfGetterOrSetter);
// Iterate over the collection of methods
for (MethodBean classMethod : methodBeans) {
// Instantiate a collection of class-defined invocations
Collection<MethodBean> definedInvocations = new ArrayList<>();
// Get the method invocations
Collection<MethodBean> classMethodInvocations = classMethod.getMethodCalls();
// Iterate over the collection of method invocations
for (MethodBean classMethodInvocation : classMethodInvocations) {
definedInvocations.add(classMethodInvocation);
}
// Set the class-defined invocations
classMethod.setMethodCalls(definedInvocations);
}
// Set the collection of methods
classBean.setMethods(methodBeans);
return classBean;
}
@Override
public boolean visit(final TypeDeclaration it) {
boolean _isDummyType = this._aSTFlattenerUtils.isDummyType(it);
if (_isDummyType) {
this.visitAll(it.bodyDeclarations(), this.nl());
return false;
}
boolean _isNotSupportedInnerType = this._aSTFlattenerUtils.isNotSupportedInnerType(it);
if (_isNotSupportedInnerType) {
StringConcatenation _builder = new StringConcatenation();
_builder.append("/* FIXME Non-static inner classes are not supported.*/");
this.appendToBuffer(_builder.toString());
this.addProblem(it, "Non-static inner classes are not supported.");
}
Javadoc _javadoc = it.getJavadoc();
boolean _tripleNotEquals = (_javadoc != null);
if (_tripleNotEquals) {
it.getJavadoc().accept(this);
}
this.appendModifiers(it, it.modifiers());
boolean _isInterface = it.isInterface();
if (_isInterface) {
this.appendToBuffer("interface ");
} else {
boolean _isPackageVisibility = this._aSTFlattenerUtils.isPackageVisibility(Iterables.<Modifier>filter(it.modifiers(), Modifier.class));
if (_isPackageVisibility) {
this.appendToBuffer("package ");
}
this.appendToBuffer("class ");
}
it.getName().accept(this);
boolean _isEmpty = it.typeParameters().isEmpty();
boolean _not = (!_isEmpty);
if (_not) {
this.appendTypeParameters(it.typeParameters());
}
this.appendSpaceToBuffer();
Type _superclassType = it.getSuperclassType();
boolean _tripleNotEquals_1 = (_superclassType != null);
if (_tripleNotEquals_1) {
this.appendToBuffer("extends ");
it.getSuperclassType().accept(this);
this.appendSpaceToBuffer();
}
boolean _isEmpty_1 = it.superInterfaceTypes().isEmpty();
boolean _not_1 = (!_isEmpty_1);
if (_not_1) {
boolean _isInterface_1 = it.isInterface();
if (_isInterface_1) {
this.appendToBuffer("extends ");
} else {
this.appendToBuffer("implements ");
}
this.visitAllSeparatedByComma(it.superInterfaceTypes());
}
this.appendToBuffer("{");
this.increaseIndent();
BodyDeclaration prev = null;
List _bodyDeclarations = it.bodyDeclarations();
for (final BodyDeclaration body : ((Iterable<BodyDeclaration>) _bodyDeclarations)) {
{
if ((prev instanceof EnumConstantDeclaration)) {
if ((body instanceof EnumConstantDeclaration)) {
this.appendToBuffer(", ");
} else {
this.appendToBuffer("; ");
}
}
this.appendLineWrapToBuffer();
body.accept(this);
prev = body;
}
}
ASTNode _root = it.getRoot();
if ((_root instanceof CompilationUnit)) {
ASTNode _root_1 = it.getRoot();
final CompilationUnit cu = ((CompilationUnit) _root_1);
final Consumer<Comment> _function = (Comment it_1) -> {
it_1.accept(this);
this.assignedComments.add(it_1);
};
this.unAssignedComments(cu).forEach(_function);
}
this.decreaseIndent();
this.appendLineWrapToBuffer();
this.appendToBuffer("}");
return false;
}
@Override
public boolean visit(final TypeDeclaration node) {
for (final Object supType : node.superInterfaceTypes()) {
Type superType = (Type) supType;
if (superType.isParameterizedType()) {
superType = ((ParameterizedType) superType).getType();
}
final String qName = superType.resolveBinding().getErasure()
.getQualifiedName();
if (className.isEmpty()) {
addTypes(qName, currentPackageName + "." + node.getName());
} else {
addTypes(qName, className.peek() + "." + node.getName());
}
}
Type superclassType = node.getSuperclassType();
if (superclassType != null) {
if (superclassType.isParameterizedType()) {
superclassType = ((ParameterizedType) superclassType)
.getType();
}
addTypes(superclassType.resolveBinding().getQualifiedName(),
currentPackageName + "." + node.getName());
}
if (className.isEmpty()) {
className.push(currentPackageName + "."
+ node.getName().getIdentifier());
importedNames.put(node.getName().getIdentifier(),
currentPackageName + "."
+ node.getName().getIdentifier());
} else {
className.push(className.peek() + "."
+ node.getName().getIdentifier());
importedNames
.put(node.getName().getIdentifier(), className.peek()
+ "." + node.getName().getIdentifier());
}
return true;
}
@SuppressWarnings("unchecked")
@Override
public boolean visit(TypeDeclaration node) {
ITypeBinding binding = node.resolveBinding();
if (binding == null) {
logNullBinding("type declaration", node.getName(),
((CompilationUnit) node.getRoot()).getLineNumber(node.getStartPosition()));
return false;
}
Type type = importer.ensureTypeFromTypeBinding(binding);
org.eclipse.jdt.core.dom.Type superclassType = node.getSuperclassType();
/*
* This is an ugly patch. When the binding to the superclass or super interfaces
* cannot be resolved, we try to recover as much info as possible We do it here
* because it is hard to pass around the dom type
*/
if (binding.getSuperclass() == null && superclassType != null)
importer.createInheritanceFromSubtypeToSuperDomType(type, superclassType);
if (superclassType != null)
type.getSuperInheritances().stream().filter(inheritance -> (inheritance.getSuperclass() instanceof Class
&& !((Class) inheritance.getSuperclass()).getIsInterface())
|| (inheritance.getSuperclass() instanceof ParameterizedType
&& ((ParameterizedType) inheritance.getSuperclass()).getParameterizableClass() != null
&& !((ParameterizedType) inheritance.getSuperclass()).getParameterizableClass()
.getIsInterface()))
.findFirst().ifPresent(in -> importer.createLightweightSourceAnchor(in, superclassType));
if (binding.getInterfaces().length == 0 && !node.superInterfaceTypes().isEmpty())
node.superInterfaceTypes().stream().forEach(t -> {
importer.createInheritanceFromSubtypeToSuperDomType(type, (org.eclipse.jdt.core.dom.Type) t);
});
// create source anchors for implemented interfaces references
createSourceAnchorsForInterfaceInheritance(node, type);
type.setIsStub(false);
importer.createSourceAnchor(type, node);
importer.createLightweightSourceAnchor(type, node.getName());
importer.ensureCommentFromBodyDeclaration(type, node);
importer.pushOnContainerStack(type);
return true;
}
@Override
public boolean visit(final TypeDeclaration node) {
for (final Object supType : node.superInterfaceTypes()) {
Type superType = (Type) supType;
if (superType.isParameterizedType()) {
superType = ((ParameterizedType) superType).getType();
}
final String qName = superType.resolveBinding().getErasure()
.getQualifiedName();
if (className.isEmpty()) {
addTypes(qName, currentPackageName + "." + node.getName());
} else {
addTypes(qName, className.peek() + "." + node.getName());
}
}
Type superclassType = node.getSuperclassType();
if (superclassType != null) {
if (superclassType.isParameterizedType()) {
superclassType = ((ParameterizedType) superclassType)
.getType();
}
addTypes(superclassType.resolveBinding().getQualifiedName(),
currentPackageName + "." + node.getName());
}
if (className.isEmpty()) {
className.push(currentPackageName + "."
+ node.getName().getIdentifier());
importedNames.put(node.getName().getIdentifier(),
currentPackageName + "."
+ node.getName().getIdentifier());
} else {
className.push(className.peek() + "."
+ node.getName().getIdentifier());
importedNames
.put(node.getName().getIdentifier(), className.peek()
+ "." + node.getName().getIdentifier());
}
return true;
}
@Override
public boolean visit(final TypeDeclaration node) {
for (final Object supType : node.superInterfaceTypes()) {
Type superType = (Type) supType;
if (superType.isParameterizedType()) {
superType = ((ParameterizedType) superType).getType();
}
final String qName = superType.resolveBinding().getErasure()
.getQualifiedName();
if (className.isEmpty()) {
addTypes(qName, currentPackageName + "." + node.getName());
} else {
addTypes(qName, className.peek() + "." + node.getName());
}
}
Type superclassType = node.getSuperclassType();
if (superclassType != null) {
if (superclassType.isParameterizedType()) {
superclassType = ((ParameterizedType) superclassType)
.getType();
}
addTypes(superclassType.resolveBinding().getQualifiedName(),
currentPackageName + "." + node.getName());
}
if (className.isEmpty()) {
className.push(currentPackageName + "."
+ node.getName().getIdentifier());
importedNames.put(node.getName().getIdentifier(),
currentPackageName + "."
+ node.getName().getIdentifier());
} else {
className.push(className.peek() + "."
+ node.getName().getIdentifier());
importedNames
.put(node.getName().getIdentifier(), className.peek()
+ "." + node.getName().getIdentifier());
}
return true;
}