Refine search
public static org.eclipse.jdt.core.dom.AbstractTypeDeclaration findTypeDeclaration(IType searchType, List<?> nodes) { for (Object object : nodes) { if (object instanceof org.eclipse.jdt.core.dom.AbstractTypeDeclaration) { org.eclipse.jdt.core.dom.AbstractTypeDeclaration typeDeclaration = (org.eclipse.jdt.core.dom.AbstractTypeDeclaration) object; if (typeDeclaration.getName().toString().equals(searchType.getElementName())) return typeDeclaration; } } return null; }
org.eclipse.jdt.core.dom.AbstractTypeDeclaration typeDeclaration = findTypeDeclaration(rootType, cuUnit.types()); while (!typeStack.isEmpty() && typeDeclaration != null) { typeDeclaration = findTypeDeclaration(typeStack.pop(), typeDeclaration.bodyDeclarations()); for (Object declaration : typeDeclaration.bodyDeclarations()) { if (declaration instanceof org.eclipse.jdt.core.dom.MethodDeclaration) { org.eclipse.jdt.core.dom.MethodDeclaration methodDeclaration = (org.eclipse.jdt.core.dom.MethodDeclaration) declaration; if (methodDeclaration.getName().toString().equals(methodName)) { return methodDeclaration;
if (type.getNodeType() == ASTNode.TYPE_DECLARATION) { List<BodyDeclaration> bodies = type.bodyDeclarations(); for (BodyDeclaration body : bodies) { if (body.getNodeType() == ASTNode.METHOD_DECLARATION) {
private boolean visitType(AbstractTypeDeclaration node) { result.add(node.getName().getIdentifier()); // don't dive into type declaration since they open a new // context. return false; } }
appendTypeParameters(buf, methodDeclaration.typeParameters()); buf.append(" void "); //$NON-NLS-1$ buf.append(methodDeclaration.getName().getIdentifier()); buf.append("(){\n"); //$NON-NLS-1$ Block body= methodDeclaration.getBody(); buf= decl.getStartPosition() < focalPosition ? bufBefore : bufAfter; appendModifiers(buf, decl.modifiers()); buf.append(type.getName().getIdentifier()); appendTypeParameters(buf, type.typeParameters()); if (type.getSuperclassType() != null) { AnnotationTypeDeclaration annotation= (AnnotationTypeDeclaration) decl; buf.append("@interface "); //$NON-NLS-1$ buf.append(annotation.getName().getIdentifier()); if (decl instanceof EnumDeclaration) buf.append(";\n"); //$NON-NLS-1$ fillWithTypeStubs(bufBefore, bufAfter, focalPosition, decl.bodyDeclarations()); buf= decl.getStartPosition() + decl.getLength() < focalPosition ? bufBefore : bufAfter; buf.append("}\n"); //$NON-NLS-1$
typeName= type.getName().getIdentifier(); } else { int visibility= JdtFlags.getVisibilityCode(type); if (visibility == Modifier.PUBLIC && maxVisibility == Modifier.PUBLIC) { int prevEnd= type.getStartPosition(); String source= text.substring(startOffset, prevEnd); cus.add(new ParsedCu(source, ASTParser.K_COMPILATION_UNIT, typeName, packageName)); typeName= type.getName().getIdentifier(); maxVisibility= visibility; } else { if (JdtFlags.isHigherVisibility(visibility, maxVisibility)) { maxVisibility= visibility; typeName= type.getName().getIdentifier();
private boolean addTypeNames(AbstractTypeDeclaration node) { final ITypeBinding typeBinding = node.resolveBinding(); if (typeBinding != null) { types.addName(FQN.fromMember(QName.valueOf(typeBinding.getQualifiedName()))); } else { // We cannot determine the FQN, so we cannot safely replace it types.cannotReplaceSimpleName(node.getName().getIdentifier()); } return VISIT_SUBTREE; }
case 0 : if (nextFieldDeclaration.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) { typeDecl.bodyDeclarations().add(convert(nextFieldDeclaration)); } else { checkAndAddMultipleFieldDeclaration(fields, fieldsIndex, typeDecl.bodyDeclarations()); methodsIndex++; if (!nextMethodDeclaration.isDefaultConstructor() && !nextMethodDeclaration.isClinit()) { typeDecl.bodyDeclarations().add(convert(isInterface, nextMethodDeclaration)); ASTNode node = convert(nextMemberDeclaration); if (node == null) { typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED); } else { typeDecl.bodyDeclarations().add(node);
this.className = typeDeclaration.getName().getFullyQualifiedName(); String typeLine = typeDeclaration.toString(); if (typeDeclaration.getJavadoc() != null) typeLine = typeLine.substring(typeDeclaration.getJavadoc().toString().length()); compilationUnit.getLineNumber(typeDeclaration.getStartPosition()), compilationUnit.getColumnNumber(compilationUnit.getStartPosition()), compilationUnit.getLength(), extractDefinitionLine(typeLine)); classReferences.add(mainTypeClassReference); processModifiers(mainTypeClassReference, typeDeclaration.modifiers()); TypeReferenceLocation.TYPE, compilationUnit.getLineNumber(typeDeclaration.getStartPosition()), compilationUnit.getColumnNumber(compilationUnit.getStartPosition()), compilationUnit.getLength(), extractDefinitionLine(typeDeclaration.toString()))); TypeReferenceLocation.TYPE, compilationUnit.getLineNumber(typeDeclaration.getStartPosition()), compilationUnit.getColumnNumber(compilationUnit.getStartPosition()), compilationUnit.getLength(), extractDefinitionLine(typeDeclaration.toString())));
private SDType visitTypeDeclaration(AbstractTypeDeclaration node, List<Type> supertypes) { SDType type; String typeName = node.getName().getIdentifier(); if (node.isLocalTypeDeclaration()) { type = model.createAnonymousType(containerStack.peek(), sourceFilePath, typeName); } else { Set<String> annotations = extractAnnotationTypes(node.modifiers()); type.setDeprecatedAnnotation(annotations.contains("Deprecated"));
@Override public boolean visit(AbstractTypeDeclaration node) { Assert.isTrue(node.getParent() instanceof TypeDeclarationStatement); result.add(node.getName().getIdentifier()); return false; }
private int findFirstMethodIndex(AbstractTypeDeclaration typeDeclaration) { for (int i= 0, n= typeDeclaration.bodyDeclarations().size(); i < n; i++) { if (typeDeclaration.bodyDeclarations().get(i) instanceof MethodDeclaration) return i; } return -1; }
private boolean checkBinding(List<AbstractTypeDeclaration> declarations, ITypeBinding binding) { for (Iterator<AbstractTypeDeclaration> iter = declarations.iterator(); iter.hasNext();) { AbstractTypeDeclaration declaration = iter.next(); if (declaration.resolveBinding() == binding) { return true; } } return false; }
private CSTypeDeclaration mapAuxillaryTypeDeclaration(AbstractTypeDeclaration node) { if (!(node instanceof TypeDeclaration) && !(node instanceof EnumDeclaration)) { unsupportedConstruct(node, "Cannot map auxillary type declaration for node."); } CSTypeDeclaration type = auxillaryTypeDeclarationFor(node); if (type == null) { return null; } type.startPosition(node.getStartPosition()); type.sourceLength(node.getLength()); return type; }
typeDecl.getName().setIdentifier(typeName); if (StubUtility.doAddComments(cu.getJavaProject())) { String typeComment= CodeGeneration.getTypeComment(cu, typeName, delim); if (typeComment != null) typeDecl.setJavadoc((Javadoc) rewrite.createStringPlaceholder(typeComment, ASTNode.JAVADOC)); typeDecl.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD)); ListRewrite bodyRewrite= rewrite.getListRewrite(typeDecl, typeDecl.getBodyDeclarationsProperty()); bodyRewrite.insertFirst(typeBodyNode, null); ListRewrite bodyRewrite= rewrite.getListRewrite(typeDecl, typeDecl.getBodyDeclarationsProperty()); BodyDeclaration textNode= (BodyDeclaration) rewrite.createStringPlaceholder(parsedText, ASTNode.METHOD_DECLARATION); bodyRewrite.insertLast(textNode, null); methodDecl.getName().setIdentifier(methodName); SingleVariableDeclaration param= ast.newSingleVariableDeclaration(); param.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("String")))); //$NON-NLS-1$ param.getName().setIdentifier("args"); //$NON-NLS-1$ methodDecl.parameters().add(param); Block block= ast.newBlock(); methodDecl.setBody(block); rewrite.getListRewrite(typeDecl, typeDecl.getBodyDeclarationsProperty()).insertLast(methodDecl, null);
@Override public boolean visit(MethodDeclaration node) { if (node.isConstructor()) { AbstractTypeDeclaration decl= ASTNodes.getParent(node, AbstractTypeDeclaration.class); NameData name= fNames.get(decl.getName().resolveBinding()); if (name != null) { name.addReference(node.getName()); } } return true; } @Override
@Override public TypeDeclaration bodyDeclaration(CompilationUnit astRoot) { String name = this.getName(); for (AbstractTypeDeclaration typeDeclaration : this.types(astRoot)) { if (typeDeclaration.getName().getFullyQualifiedName().equals(name)) { return (TypeDeclaration) typeDeclaration; // assume no enum or annotation declarations } } return null; }
private Iterator<ASTNode> getReplacementScope() throws JavaModelException { boolean declPredecessorReached = false; Collection<ASTNode> scope = new ArrayList<>(); AbstractTypeDeclaration containingType = getContainingTypeDeclarationNode(); if (containingType instanceof EnumDeclaration) { // replace in all enum constants bodies EnumDeclaration enumDeclaration = (EnumDeclaration) containingType; scope.addAll(enumDeclaration.enumConstants()); } for (Iterator<IExtendedModifier> iter = containingType.modifiers().iterator(); iter.hasNext();) { IExtendedModifier modifier = iter.next(); if (modifier instanceof Annotation) { scope.add((ASTNode) modifier); } } for (Iterator<BodyDeclaration> bodyDeclarations = containingType.bodyDeclarations().iterator(); bodyDeclarations.hasNext();) { BodyDeclaration bodyDeclaration = bodyDeclarations.next(); if (bodyDeclaration == getNodeToInsertConstantDeclarationAfter()) { declPredecessorReached = true; } if (insertFirst() || declPredecessorReached || !isStaticFieldOrStaticInitializer(bodyDeclaration)) { scope.add(bodyDeclaration); } } return scope.iterator(); }
if (index == -1) { AbstractTypeDeclaration typeNode= (AbstractTypeDeclaration) astRoot.types().get(0); int start= ((ASTNode) typeNode.modifiers().get(0)).getStartPosition(); int end= typeNode.getStartPosition() + typeNode.getLength(); buffer.replace(start, end - start, typeContent); } else {
public boolean visit(org.eclipse.jdt.core.dom.CompilationUnit compilationUnit) { List types = compilationUnit.types(); boolean contains_malformed_nodes = false; for (Iterator iter = types.iterator(); iter.hasNext();) { AbstractTypeDeclaration typeDeclaration = (AbstractTypeDeclaration) iter.next(); typeDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, Integer.valueOf(typeDeclaration.getStartPosition())); contains_malformed_nodes |= Boolean.valueOf(isMalformed(typeDeclaration)); } compilationUnit.setProperty(CONTAINS_MALFORMED_NODES, contains_malformed_nodes); return true; } public boolean visit(AnnotationTypeDeclaration annotationTypeDeclaration) {