List of usage examples for org.eclipse.jdt.core.dom AbstractTypeDeclaration bodyDeclarations
ASTNode.NodeList bodyDeclarations
To view the source code for org.eclipse.jdt.core.dom AbstractTypeDeclaration bodyDeclarations.
Click Source Link
From source file:com.crispico.flower.mp.codesync.code.java.adapter.JavaTypeModelAdapter.java
License:Open Source License
/** * Returns only types, fields and methods. *///from w w w. j av a 2 s. c o m @Override public List<?> getChildren(Object modelElement) { List children = new ArrayList<>(); AbstractTypeDeclaration type = getAbstractTypeDeclaration(modelElement); children.addAll(type.bodyDeclarations()); if (type instanceof EnumDeclaration) { children.addAll(((EnumDeclaration) type).enumConstants()); } Iterator it = new FilteredIterable(children.iterator()) { @Override protected boolean isAccepted(Object candidate) { if (candidate instanceof AbstractTypeDeclaration) { return true; } if (candidate instanceof FieldDeclaration) { return true; } if (candidate instanceof MethodDeclaration) { return true; } // children of EnumDeclaration if (candidate instanceof EnumConstantDeclaration) { return true; } // children of AnnotationTypeDeclaration if (candidate instanceof AnnotationTypeMemberDeclaration) { return true; } return false; } }; List rslt = new ArrayList(); while (it.hasNext()) { ASTNode node = (ASTNode) it.next(); // TODO for field declarations, add the list of fragments // if (node instanceof FieldDeclaration) { // rslt.addAll(((FieldDeclaration) node).fragments()); // } else { rslt.add(node); // } } return rslt; }
From source file:com.crispico.flower.mp.codesync.code.java.adapter.JavaTypeModelAdapter.java
License:Open Source License
@Override public Object createChildOnContainmentFeature(Object element, Object feature, Object correspondingChild) { // declared as containment by JavaFeatureProvider if (AstCacheCodePackage.eINSTANCE.getClass_SuperInterfaces().equals(feature)) { if (element instanceof TypeDeclaration || element instanceof EnumDeclaration) { String superInterface = (String) correspondingChild; AbstractTypeDeclaration cls = (AbstractTypeDeclaration) element; AST ast = cls.getAST();//from ww w. j ava2 s . co m Type type = getTypeFromString(ast, superInterface); if (cls instanceof TypeDeclaration) { ((TypeDeclaration) cls).superInterfaceTypes().add(type); } if (cls instanceof EnumDeclaration) { ((EnumDeclaration) cls).superInterfaceTypes().add(type); } return getStringFromType(type); } return null; } if (AstCacheCodePackage.eINSTANCE.getClass_SuperClasses().equals(feature)) { if (element instanceof TypeDeclaration) { String superClass = (String) correspondingChild; TypeDeclaration cls = (TypeDeclaration) element; AST ast = cls.getAST(); Type type = getTypeFromString(ast, superClass); cls.setSuperclassType(type); return getStringFromType(type); } return null; } if (CodeSyncPackage.eINSTANCE.getCodeSyncElement_Children().equals(feature)) { CodeSyncElement cse = (CodeSyncElement) correspondingChild; AstCacheElement ace = cse.getAstCacheElement(); AbstractTypeDeclaration parent = (AbstractTypeDeclaration) element; AST ast = parent.getAST(); ASTNode child = (ASTNode) createCorrespondingModelElement(ast, cse); parent.bodyDeclarations().add(child); return child; } return super.createChildOnContainmentFeature(element, feature, correspondingChild); }
From source file:com.github.parzonka.ccms.engine.SortElementsOperation.java
License:Open Source License
private ASTRewrite sortCompilationUnit(org.eclipse.jdt.core.dom.CompilationUnit ast, final TextEditGroup group) { ast.accept(new ASTVisitor() { @Override/*w w w .j av a2 s. c o m*/ public boolean visit(org.eclipse.jdt.core.dom.CompilationUnit compilationUnit) { final List<AbstractTypeDeclaration> types = compilationUnit.types(); for (final Iterator<AbstractTypeDeclaration> iter = types.iterator(); iter.hasNext();) { final AbstractTypeDeclaration typeDeclaration = iter.next(); typeDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, new Integer(typeDeclaration.getStartPosition())); compilationUnit.setProperty(CONTAINS_MALFORMED_NODES, Boolean.valueOf(isMalformed(typeDeclaration))); } return true; } @Override public boolean visit(AnnotationTypeDeclaration annotationTypeDeclaration) { final List bodyDeclarations = annotationTypeDeclaration.bodyDeclarations(); for (final Iterator iter = bodyDeclarations.iterator(); iter.hasNext();) { final BodyDeclaration bodyDeclaration = (BodyDeclaration) iter.next(); bodyDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, new Integer(bodyDeclaration.getStartPosition())); annotationTypeDeclaration.setProperty(CONTAINS_MALFORMED_NODES, Boolean.valueOf(isMalformed(bodyDeclaration))); } return true; } @Override public boolean visit(AnonymousClassDeclaration anonymousClassDeclaration) { final List bodyDeclarations = anonymousClassDeclaration.bodyDeclarations(); for (final Iterator iter = bodyDeclarations.iterator(); iter.hasNext();) { final BodyDeclaration bodyDeclaration = (BodyDeclaration) iter.next(); bodyDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, new Integer(bodyDeclaration.getStartPosition())); anonymousClassDeclaration.setProperty(CONTAINS_MALFORMED_NODES, Boolean.valueOf(isMalformed(bodyDeclaration))); } return true; } @Override public boolean visit(TypeDeclaration typeDeclaration) { final List bodyDeclarations = typeDeclaration.bodyDeclarations(); for (final Iterator iter = bodyDeclarations.iterator(); iter.hasNext();) { final BodyDeclaration bodyDeclaration = (BodyDeclaration) iter.next(); bodyDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, new Integer(bodyDeclaration.getStartPosition())); typeDeclaration.setProperty(CONTAINS_MALFORMED_NODES, Boolean.valueOf(isMalformed(bodyDeclaration))); } return true; } @Override public boolean visit(EnumDeclaration enumDeclaration) { final List bodyDeclarations = enumDeclaration.bodyDeclarations(); for (final Iterator iter = bodyDeclarations.iterator(); iter.hasNext();) { final BodyDeclaration bodyDeclaration = (BodyDeclaration) iter.next(); bodyDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, new Integer(bodyDeclaration.getStartPosition())); enumDeclaration.setProperty(CONTAINS_MALFORMED_NODES, Boolean.valueOf(isMalformed(bodyDeclaration))); } final List enumConstants = enumDeclaration.enumConstants(); for (final Iterator iter = enumConstants.iterator(); iter.hasNext();) { final EnumConstantDeclaration enumConstantDeclaration = (EnumConstantDeclaration) iter.next(); enumConstantDeclaration.setProperty(CompilationUnitSorter.RELATIVE_ORDER, new Integer(enumConstantDeclaration.getStartPosition())); enumDeclaration.setProperty(CONTAINS_MALFORMED_NODES, Boolean.valueOf(isMalformed(enumConstantDeclaration))); } return true; } }); final ASTRewrite rewriter = ASTRewrite.create(ast.getAST()); final boolean[] hasChanges = new boolean[] { false }; ast.accept(new ASTVisitor() { /** * This * * @param elements * @param listRewrite */ private void sortElements(List<BodyDeclaration> elements, ListRewrite listRewrite) { if (elements.size() == 0) return; final List<BodyDeclaration> myCopy = new ArrayList<BodyDeclaration>(); myCopy.addAll(elements); // orderexperiment final List<Signature> methods = new ArrayList<Signature>(); for (final BodyDeclaration bd : myCopy) { if (bd.getNodeType() == ASTNode.METHOD_DECLARATION) { methods.add(new Signature((MethodDeclaration) bd)); } } Collections.sort(methods, ((BodyDeclarationComparator) SortElementsOperation.this.comparator) .getMethodDeclarationComparator()); logger.info("Sorting of methods based on appearance:"); int j = 0; for (final Signature sig : methods) { logger.info("Method [{}] : {}", ++j, sig); } Collections.sort(myCopy, SortElementsOperation.this.comparator); logger.info("Final sorting order just before the AST-Rewrite:"); for (final BodyDeclaration bd : myCopy) { if (bd.getNodeType() == ASTNode.METHOD_DECLARATION) { logger.info("{}", new Signature((MethodDeclaration) bd)); } else { logger.info("{}", bd.toString()); } } for (int i = 0; i < elements.size(); i++) { final BodyDeclaration oldNode = elements.get(i); final BodyDeclaration newNode = myCopy.get(i); if (oldNode != newNode) { if (oldNode.getNodeType() == ASTNode.METHOD_DECLARATION && newNode.getNodeType() == ASTNode.METHOD_DECLARATION) { final Signature oldMethodSignature = new Signature((MethodDeclaration) oldNode); final Signature newMethodSignature = new Signature((MethodDeclaration) newNode); logger.trace("Swapping [{}]for [{}]", oldMethodSignature, newMethodSignature); } else { logger.trace("Swapping [{}]for [{}]", oldNode.getNodeType(), newNode.getNodeType()); } listRewrite.replace(oldNode, rewriter.createMoveTarget(newNode), group); hasChanges[0] = true; } } } @Override public boolean visit(org.eclipse.jdt.core.dom.CompilationUnit compilationUnit) { if (checkMalformedNodes(compilationUnit)) { logger.warn("Malformed nodes. Aborting sorting of current element."); return true; } sortElements(compilationUnit.types(), rewriter.getListRewrite(compilationUnit, org.eclipse.jdt.core.dom.CompilationUnit.TYPES_PROPERTY)); return true; } @Override public boolean visit(AnnotationTypeDeclaration annotationTypeDeclaration) { if (checkMalformedNodes(annotationTypeDeclaration)) { logger.warn("Malformed nodes. Aborting sorting of current element."); return true; } sortElements(annotationTypeDeclaration.bodyDeclarations(), rewriter.getListRewrite( annotationTypeDeclaration, AnnotationTypeDeclaration.BODY_DECLARATIONS_PROPERTY)); return true; } @Override public boolean visit(AnonymousClassDeclaration anonymousClassDeclaration) { if (checkMalformedNodes(anonymousClassDeclaration)) { logger.warn("Malformed nodes. Aborting sorting of current element."); return true; } sortElements(anonymousClassDeclaration.bodyDeclarations(), rewriter.getListRewrite( anonymousClassDeclaration, AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY)); return true; } @Override public boolean visit(TypeDeclaration typeDeclaration) { if (checkMalformedNodes(typeDeclaration)) { logger.warn("Malformed nodes. Aborting sorting of current element."); return true; } sortElements(typeDeclaration.bodyDeclarations(), rewriter.getListRewrite(typeDeclaration, TypeDeclaration.BODY_DECLARATIONS_PROPERTY)); return true; } @Override public boolean visit(EnumDeclaration enumDeclaration) { if (checkMalformedNodes(enumDeclaration)) { return true; // abort sorting of current element } sortElements(enumDeclaration.bodyDeclarations(), rewriter.getListRewrite(enumDeclaration, EnumDeclaration.BODY_DECLARATIONS_PROPERTY)); sortElements(enumDeclaration.enumConstants(), rewriter.getListRewrite(enumDeclaration, EnumDeclaration.ENUM_CONSTANTS_PROPERTY)); return true; } }); if (!hasChanges[0]) return null; return rewriter; }
From source file:com.google.currysrc.api.process.ast.FieldLocator.java
License:Apache License
@Override public FieldDeclaration find(CompilationUnit cu) { AbstractTypeDeclaration typeDeclaration = typeLocator.find(cu); if (typeDeclaration == null) { return null; }//w w w. j a v a 2 s . c om for (BodyDeclaration bodyDeclaration : (List<BodyDeclaration>) typeDeclaration.bodyDeclarations()) { if (bodyDeclaration instanceof FieldDeclaration) { FieldDeclaration fieldDeclaration = (FieldDeclaration) bodyDeclaration; for (VariableDeclarationFragment variableDeclarationFragment : (List<VariableDeclarationFragment>) fieldDeclaration .fragments()) { String nodeFieldName = variableDeclarationFragment.getName().getFullyQualifiedName(); if (nodeFieldName.equals(fieldName)) { return fieldDeclaration; } } } } return null; }
From source file:com.google.currysrc.api.process.ast.MethodLocator.java
License:Apache License
@Override public MethodDeclaration find(CompilationUnit cu) { AbstractTypeDeclaration typeDeclaration = typeLocator.find(cu); if (typeDeclaration == null) { return null; }/* w w w . j a v a2s .c o m*/ for (BodyDeclaration bodyDeclaration : (List<BodyDeclaration>) typeDeclaration.bodyDeclarations()) { if (bodyDeclaration instanceof MethodDeclaration) { MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration; if (methodDeclaration.getName().getFullyQualifiedName().equals(methodName)) { if (parameterMatcher.matches(methodDeclaration)) { return methodDeclaration; } } } } return null; }
From source file:com.google.currysrc.api.process.ast.TypeLocator.java
License:Apache License
private AbstractTypeDeclaration findNested(Iterator<String> classNameIterator, AbstractTypeDeclaration typeDeclaration) { if (!classNameIterator.hasNext()) { return typeDeclaration; }/* w w w . j a va 2 s . c o m*/ String subClassName = classNameIterator.next(); for (BodyDeclaration bodyDeclaration : (List<BodyDeclaration>) typeDeclaration.bodyDeclarations()) { if (bodyDeclaration instanceof AbstractTypeDeclaration) { AbstractTypeDeclaration subTypeDeclaration = (AbstractTypeDeclaration) bodyDeclaration; if (subTypeDeclaration.getName().getFullyQualifiedName().equals(subClassName)) { return findNested(classNameIterator, subTypeDeclaration); } } } return null; }
From source file:com.google.devtools.j2cpp.translate.InitializationNormalizer.java
License:Open Source License
void normalizeMembers(AbstractTypeDeclaration node) { List<Statement> initStatements = Lists.newArrayList(); List<Statement> classInitStatements = Lists.newArrayList(); List<MethodDeclaration> methods = Lists.newArrayList(); ITypeBinding binding = Types.getTypeBinding(node); // Scan class, gathering initialization statements in declaration order. @SuppressWarnings("unchecked") List<BodyDeclaration> members = node.bodyDeclarations(); // safe by specification Iterator<BodyDeclaration> iterator = members.iterator(); while (iterator.hasNext()) { BodyDeclaration member = iterator.next(); switch (member.getNodeType()) { case ASTNode.ENUM_DECLARATION: case ASTNode.TYPE_DECLARATION: normalizeMembers((AbstractTypeDeclaration) member); break; case ASTNode.METHOD_DECLARATION: methods.add((MethodDeclaration) member); break; case ASTNode.INITIALIZER: addInitializer(member, initStatements, classInitStatements); iterator.remove();/*from w ww . ja v a 2 s .com*/ break; case ASTNode.FIELD_DECLARATION: if (!binding.isInterface()) { // All interface fields are constants. addFieldInitializer(member, initStatements, classInitStatements); } break; } } // Update any primary constructors with init statements. if (!initStatements.isEmpty() || binding.isEnum()) { boolean needsConstructor = true; for (MethodDeclaration md : methods) { if (md.isConstructor()) { needsConstructor = false; } normalizeMethod(md, initStatements); } if (needsConstructor) { addDefaultConstructor(binding, members, initStatements, node.getAST()); } } // Create an initialize method, if necessary. if (!classInitStatements.isEmpty()) { addClassInitializer(binding, members, classInitStatements, node.getAST()); } }
From source file:com.google.devtools.j2cpp.translate.InnerClassExtractor.java
License:Open Source License
public boolean visitType(AbstractTypeDeclaration node) { ASTNode parentNode = node.getParent(); if (!(parentNode instanceof CompilationUnit)) { ITypeBinding type = Types.getTypeBinding(node); if (!type.isInterface() && !type.isAnnotation() && !Modifier.isStatic(type.getModifiers())) { addOuterFields(node);//from w ww . jav a 2 s . com } if (parentNode instanceof AbstractTypeDeclaration) { // Remove declaration from declaring type. AbstractTypeDeclaration parent = (AbstractTypeDeclaration) node.getParent(); @SuppressWarnings("unchecked") List<AbstractTypeDeclaration> parentTypes = parent.bodyDeclarations(); // safe by definition boolean success = parentTypes.remove(node); assert success; } else { TypeDeclarationStatement typeStatement = (TypeDeclarationStatement) parentNode; node = NodeCopier.copySubtree(node.getAST(), typeStatement.getDeclaration()); // Remove stmt from method body (or an if/else/try/catch/finally clause). Block body = (Block) typeStatement.getParent(); @SuppressWarnings("unchecked") List<Statement> stmts = body.statements(); // safe by definition boolean success = stmts.remove(typeStatement); assert success; } // Make this node non-private, if necessary, and add it to the unit's type // list. @SuppressWarnings("unchecked") // safe by definition List<IExtendedModifier> modifiers = node.modifiers(); for (IExtendedModifier iem : modifiers) { if (iem instanceof Modifier) { Modifier mod = (Modifier) iem; if (mod.getKeyword().equals(ModifierKeyword.PRIVATE_KEYWORD)) { modifiers.remove(mod); break; } } } unitTypes.add(node); } return true; }
From source file:com.google.devtools.j2cpp.translate.InnerClassExtractor.java
License:Open Source License
private void addOuterFields(AbstractTypeDeclaration node) { @SuppressWarnings("unchecked") List<BodyDeclaration> members = node.bodyDeclarations(); // safe by definition AST ast = node.getAST();/*w w w . jav a 2s . c om*/ ITypeBinding clazz = Types.getTypeBinding(node); ITypeBinding outerClazz = clazz.getDeclaringClass(); assert outerClazz != null; List<IVariableBinding> innerFields = Lists.newArrayList(); // Ensure that the new outer field does not conflict with a field in a superclass. ITypeBinding superClazz = clazz.getSuperclass(); ITypeBinding superDeclaringClazz = superClazz.getDeclaringClass(); int suffix = 0; while (superClazz.getDeclaringClass() != null) { if (!Modifier.isStatic(superClazz.getModifiers())) { suffix++; } superClazz = superClazz.getSuperclass(); } String outerFieldName = "this$" + suffix; FieldDeclaration outerField = createField(outerFieldName, outerClazz, clazz, ast); members.add(0, outerField); IVariableBinding outerVar = Types.getVariableBinding(outerField.fragments().get(0)); innerFields.add(outerVar); if (superDeclaringClazz != null && !Modifier.isStatic(clazz.getSuperclass().getModifiers()) && !outerClazz.isAssignmentCompatible(superDeclaringClazz.getTypeDeclaration())) { // The super class is an inner class, and it's declaring class and the // current node's declaring class don't match, so we need another outer // var. This var is only a parameter, not a field, an it's name doesn't // matter because addInnerParameters will assign a different name to it // anyway. IVariableBinding secondOuterVar = new GeneratedVariableBinding("", Modifier.FINAL, superDeclaringClazz, false, true, superClazz, null); innerFields.add(secondOuterVar); } // Insert new parameters for each constructor in class. boolean needsConstructor = true; for (BodyDeclaration member : members) { if (member instanceof MethodDeclaration && ((MethodDeclaration) member).isConstructor()) { needsConstructor = false; MethodDeclaration constructor = (MethodDeclaration) member; IMethodBinding oldBinding = Types.getMethodBinding(constructor); GeneratedMethodBinding newBinding = new GeneratedMethodBinding(oldBinding); Types.addBinding(constructor, newBinding); addInnerParameters(constructor, newBinding, innerFields, ast, false); assert constructor.parameters().size() == newBinding.getParameterTypes().length; } } if (needsConstructor) { MethodDeclaration constructor = ast.newMethodDeclaration(); constructor.setConstructor(true); ITypeBinding voidType = ast.resolveWellKnownType("void"); GeneratedMethodBinding binding = new GeneratedMethodBinding("init", 0, voidType, clazz, true, false, true); Types.addBinding(constructor, binding); Types.addBinding(constructor.getReturnType2(), voidType); SimpleName name = ast.newSimpleName("init"); Types.addBinding(name, binding); constructor.setName(name); constructor.setBody(ast.newBlock()); addInnerParameters(constructor, binding, innerFields, ast, false); members.add(constructor); assert constructor.parameters().size() == binding.getParameterTypes().length; } }
From source file:com.google.devtools.j2objc.translate.InnerClassExtractorTest.java
License:Open Source License
/** * Verify that a static inner class is extracted. *///from w w w . ja v a 2 s .co m public void testStaticInnerClass() { List<AbstractTypeDeclaration> types = translateClassBody( "static class Foo { int i; Foo() { this(0); } Foo(int i) { this.i = i; } }"); assertEquals(2, types.size()); List<BodyDeclaration> classMembers = ASTUtil.getBodyDeclarations(types.get(0)); assertTrue(classMembers.size() == 1); AbstractTypeDeclaration innerClass = types.get(1); assertEquals(4, innerClass.bodyDeclarations().size()); List<BodyDeclaration> members = ASTUtil.getBodyDeclarations(innerClass); FieldDeclaration field = (FieldDeclaration) members.get(0); assertEquals("int", field.getType().toString()); MethodDeclaration method = (MethodDeclaration) members.get(1); assertTrue(method.isConstructor()); assertTrue(method.parameters().isEmpty()); assertEquals(1, method.getBody().statements().size()); ConstructorInvocation stmt = (ConstructorInvocation) method.getBody().statements().get(0); assertEquals(1, stmt.arguments().size()); method = (MethodDeclaration) members.get(2); assertTrue(method.isConstructor()); assertEquals(1, method.parameters().size()); assertEquals(2, method.getBody().statements().size()); ExpressionStatement expr = (ExpressionStatement) method.getBody().statements().get(1); assertTrue(expr.getExpression() instanceof Assignment); }