Example usage for org.eclipse.jdt.core.dom Modifier getKeyword

List of usage examples for org.eclipse.jdt.core.dom Modifier getKeyword

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. Modifier
  6. getKeyword

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom Modifier getKeyword.

Prototype

public ModifierKeyword getKeyword()

Source Link

Document

Returns the modifier keyword of this modifier node.

Usage

From source file:at.bestsolution.fxide.jdt.corext.dom.ASTFlattener.java

License:Open Source License

@Override
public boolean visit(Modifier node) {
    this.fBuffer.append(node.getKeyword().toString());
    return false;
}

From source file:boa.datagen.util.Java7Visitor.java

License:Apache License

@Override
public boolean visit(org.eclipse.jdt.core.dom.Modifier node) {
    boa.types.Ast.Modifier.Builder b = boa.types.Ast.Modifier.newBuilder();
    //      b.setPosition(pos.build());
    if (node.isFinal())
        b.setKind(boa.types.Ast.Modifier.ModifierKind.FINAL);
    else if (node.isAbstract())
        b.setKind(boa.types.Ast.Modifier.ModifierKind.ABSTRACT);
    else if (node.isStatic())
        b.setKind(boa.types.Ast.Modifier.ModifierKind.STATIC);
    else if (node.isSynchronized())
        b.setKind(boa.types.Ast.Modifier.ModifierKind.SYNCHRONIZED);
    else if (node.isPublic()) {
        b.setKind(boa.types.Ast.Modifier.ModifierKind.VISIBILITY);
        b.setVisibility(boa.types.Ast.Modifier.Visibility.PUBLIC);
    } else if (node.isPrivate()) {
        b.setKind(boa.types.Ast.Modifier.ModifierKind.VISIBILITY);
        b.setVisibility(boa.types.Ast.Modifier.Visibility.PRIVATE);
    } else if (node.isProtected()) {
        b.setKind(boa.types.Ast.Modifier.ModifierKind.VISIBILITY);
        b.setVisibility(boa.types.Ast.Modifier.Visibility.PROTECTED);
    } else {//ww w . ja  v  a 2  s.  co  m
        b.setKind(boa.types.Ast.Modifier.ModifierKind.OTHER);
        b.setOther(node.getKeyword().toString());
    }
    modifiers.push(b.build());
    return false;
}

From source file:changenodes.matching.BestLeafTreeMatcher.java

License:Apache License

private void markBodyDeclaration(ASTNode x, ASTNode y) {
    BodyDeclaration leftMethod = (BodyDeclaration) x;
    BodyDeclaration rightMethod = (BodyDeclaration) y;
    List<IExtendedModifier> leftModifiers = (List<IExtendedModifier>) leftMethod.modifiers();
    List<IExtendedModifier> rightModifiers = (List<IExtendedModifier>) rightMethod.modifiers();
    for (IExtendedModifier lm : leftModifiers) {
        if (lm.isModifier()) {
            for (IExtendedModifier rm : rightModifiers) {
                if (rm.isModifier()) {
                    Modifier clm = (Modifier) lm;
                    Modifier crm = (Modifier) rm;
                    if (crm.getKeyword().equals(clm.getKeyword())) {
                        leftMatching.put(clm, crm);
                        rightMatching.put(crm, clm);
                    }//w  w w.  jav a  2s .  c o  m
                }
            }
        }
    }
}

From source file:chibi.gumtreediff.gen.jdt.cd.CdJdtVisitor.java

License:Open Source License

@Override
public boolean visit(Modifier node) {
    pushNode(node, node.getKeyword().toString());
    return false;
}

From source file:coloredide.utils.CopiedNaiveASTFlattener.java

License:Open Source License

public boolean visit(Modifier node) {
    this.buffer.append(node.getKeyword().toString());
    return false;
}

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  ww  w .  j a  v  a2s  .c  o m
        }

        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:edu.umd.cs.findbugs.plugin.eclipse.quickfix.ChangePublicToProtectedResolution.java

License:Open Source License

private Modifier getPublicModifier(MethodDeclaration method) {
    List<?> list = method.modifiers();
    for (Object o : list) {
        if (o.getClass().equals(Modifier.class)) {
            Modifier mdf = (Modifier) o;
            if (mdf.getKeyword().equals(PUBLIC_KEYWORD)) {
                return mdf;
            }//from w  ww.j a v a2  s. c o  m
        }

    }
    return null;
}

From source file:lang.java.jdt.internal.JdtAstToRascalAstConverter.java

License:Open Source License

public boolean visit(Modifier node) {
    if (node.getKeyword().equals(ModifierKeyword.PUBLIC_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_PUBLIC);
    } else if (node.getKeyword().equals(ModifierKeyword.PROTECTED_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_PROTECTED);
    } else if (node.getKeyword().equals(ModifierKeyword.PRIVATE_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_PRIVATE);
    } else if (node.getKeyword().equals(ModifierKeyword.STATIC_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_STATIC);
    } else if (node.getKeyword().equals(ModifierKeyword.ABSTRACT_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_ABSTRACT);
    } else if (node.getKeyword().equals(ModifierKeyword.FINAL_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_FINAL);
    } else if (node.getKeyword().equals(ModifierKeyword.SYNCHRONIZED_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_SYNCHRONIZED);
    } else if (node.getKeyword().equals(ModifierKeyword.VOLATILE_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_VOLATILE);
    } else if (node.getKeyword().equals(ModifierKeyword.NATIVE_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_NATIVE);
    } else if (node.getKeyword().equals(ModifierKeyword.STRICTFP_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_STRICTFP);
    } else if (node.getKeyword().equals(ModifierKeyword.TRANSIENT_KEYWORD)) {
        ownValue = values.constructor(Java.CONS_TRANSIENT);
    }//from  w  w  w.j a  va  2s.  c o  m

    return false;
}

From source file:net.sf.eclipsecs.ui.quickfixes.modifier.ModifierOrderQuickfix.java

License:Open Source License

/**
 * Reorders the given list of <code>Modifier</code> nodes into their suggested order by the JLS.
 *
 * @param modifiers/*from ww  w .ja  v a 2s .  c  o  m*/
 *            the list of modifiers to reorder
 * @return the reordered list of modifiers
 */
public static List reOrderModifiers(List modifiers) {

    List copies = new ArrayList();
    Iterator it = modifiers.iterator();
    while (it.hasNext()) {
        ASTNode mod = (ASTNode) it.next();
        copies.add(ASTNode.copySubtree(mod.getAST(), mod));
    }

    // oder modifiers to correct order
    Collections.sort(copies, new Comparator() {
        public int compare(Object arg0, Object arg1) {
            if (!(arg0 instanceof Modifier) || !(arg1 instanceof Modifier)) {
                return 0;
            }

            Modifier m1 = (Modifier) arg0;
            Modifier m2 = (Modifier) arg1;

            int modifierIndex1 = MODIFIER_ORDER.indexOf(m1.getKeyword());
            int modifierIndex2 = MODIFIER_ORDER.indexOf(m2.getKeyword());

            return new Integer(modifierIndex1).compareTo(new Integer(modifierIndex2));
        }
    });

    return copies;
}

From source file:net.sf.eclipsecs.ui.quickfixes.modifier.RedundantModifierQuickfix.java

License:Open Source License

/**
 * {@inheritDoc}/*  www .  j a  v  a  2 s  . c  o  m*/
 */
protected ASTVisitor handleGetCorrectingASTVisitor(final IRegion lineInfo, final int markerStartOffset) {

    return new ASTVisitor() {

        public boolean visit(MethodDeclaration node) {

            if (containsPosition(node, markerStartOffset)) {
                List<ModifierKeyword> redundantKeyWords = Collections.emptyList();

                if (node.getParent() instanceof TypeDeclaration) {
                    TypeDeclaration type = (TypeDeclaration) node.getParent();
                    if (type.isInterface()) {
                        redundantKeyWords = Arrays
                                .asList(new ModifierKeyword[] { ModifierKeyword.PUBLIC_KEYWORD,
                                        ModifierKeyword.ABSTRACT_KEYWORD, ModifierKeyword.FINAL_KEYWORD });
                    } else if (Modifier.isFinal(type.getModifiers())) {
                        redundantKeyWords = Arrays
                                .asList(new ModifierKeyword[] { ModifierKeyword.FINAL_KEYWORD });
                    }
                }

                deleteRedundantModifiers(node.modifiers(), redundantKeyWords);
            }
            return true;
        }

        public boolean visit(FieldDeclaration node) {
            // recalculate start position because optional javadoc is mixed
            // into the original start position
            int pos = node.getStartPosition()
                    + (node.getJavadoc() != null ? node.getJavadoc().getLength() + JAVADOC_COMMENT_LENGTH : 0);
            if (containsPosition(lineInfo, pos)) {
                List<ModifierKeyword> redundantKeyWords = Collections.emptyList();

                if (node.getParent() instanceof TypeDeclaration) {
                    TypeDeclaration type = (TypeDeclaration) node.getParent();
                    if (type.isInterface()) {
                        redundantKeyWords = Arrays.asList(new ModifierKeyword[] {
                                ModifierKeyword.PUBLIC_KEYWORD, ModifierKeyword.ABSTRACT_KEYWORD,
                                ModifierKeyword.FINAL_KEYWORD, ModifierKeyword.STATIC_KEYWORD });
                    }
                } else if (node.getParent() instanceof AnnotationTypeDeclaration) {

                    redundantKeyWords = Arrays.asList(new ModifierKeyword[] { ModifierKeyword.PUBLIC_KEYWORD,
                            ModifierKeyword.ABSTRACT_KEYWORD, ModifierKeyword.FINAL_KEYWORD,
                            ModifierKeyword.STATIC_KEYWORD });
                }

                deleteRedundantModifiers(node.modifiers(), redundantKeyWords);
            }
            return true;
        }

        public boolean visit(AnnotationTypeMemberDeclaration node) {

            // recalculate start position because optional javadoc is mixed
            // into the original start position
            int pos = node.getStartPosition()
                    + (node.getJavadoc() != null ? node.getJavadoc().getLength() + JAVADOC_COMMENT_LENGTH : 0);
            if (containsPosition(lineInfo, pos)) {

                if (node.getParent() instanceof AnnotationTypeDeclaration) {

                    List<ModifierKeyword> redundantKeyWords = Arrays.asList(new ModifierKeyword[] {
                            ModifierKeyword.PUBLIC_KEYWORD, ModifierKeyword.ABSTRACT_KEYWORD,
                            ModifierKeyword.FINAL_KEYWORD, ModifierKeyword.STATIC_KEYWORD });

                    deleteRedundantModifiers(node.modifiers(), redundantKeyWords);
                }

            }
            return true;
        }

        private void deleteRedundantModifiers(List<ASTNode> modifiers,
                List<ModifierKeyword> redundantModifierKeywords) {

            Iterator<ASTNode> it = modifiers.iterator();

            while (it.hasNext()) {
                ASTNode node = it.next();

                if (node instanceof Modifier) {
                    Modifier modifier = (Modifier) node;
                    if (redundantModifierKeywords.contains(modifier.getKeyword())) {
                        it.remove();
                    }
                }
            }
        }
    };
}