List of usage examples for org.eclipse.jdt.core.dom BodyDeclaration getModifiers
public int getModifiers()
From source file:at.bestsolution.fxide.jdt.corext.util.JdtFlags.java
License:Open Source License
public static boolean isStatic(BodyDeclaration bodyDeclaration) { if (isNestedInterfaceOrAnnotation(bodyDeclaration)) return true; int nodeType = bodyDeclaration.getNodeType(); if (!(nodeType == ASTNode.METHOD_DECLARATION || nodeType == ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION) && isInterfaceOrAnnotationMember(bodyDeclaration)) return true; if (bodyDeclaration instanceof EnumConstantDeclaration) return true; if (bodyDeclaration instanceof EnumDeclaration && bodyDeclaration.getParent() instanceof AbstractTypeDeclaration) return true; return Modifier.isStatic(bodyDeclaration.getModifiers()); }
From source file:at.bestsolution.fxide.jdt.corext.util.JdtFlags.java
License:Open Source License
public static boolean isPrivate(BodyDeclaration bodyDeclaration) { return Modifier.isPrivate(bodyDeclaration.getModifiers()); }
From source file:at.bestsolution.fxide.jdt.corext.util.JdtFlags.java
License:Open Source License
public static boolean isProtected(BodyDeclaration bodyDeclaration) { return Modifier.isProtected(bodyDeclaration.getModifiers()); }
From source file:at.bestsolution.fxide.jdt.corext.util.JdtFlags.java
License:Open Source License
public static boolean isPublic(BodyDeclaration bodyDeclaration) { if (isInterfaceOrAnnotationMember(bodyDeclaration)) return true; return Modifier.isPublic(bodyDeclaration.getModifiers()); }
From source file:com.crispico.flower.mp.metamodel.codesyncjava.algorithm.JavaSyncUtils.java
License:Open Source License
/** * @flowerModelElementId _zVs8ZJiOEd6aNMdNFvR5WQ *///from w w w . j a v a 2 s .co m public static ModifierKeyword getJavaVisibilityFlagFromJavaClass(BodyDeclaration bd) { if (Modifier.isPrivate(bd.getModifiers())) return ModifierKeyword.PRIVATE_KEYWORD; else if (Modifier.isProtected(bd.getModifiers())) return ModifierKeyword.PROTECTED_KEYWORD; else if (Modifier.isPublic(bd.getModifiers())) return ModifierKeyword.PUBLIC_KEYWORD; return null; }
From source file:com.crispico.flower.mp.metamodel.codesyncjava.algorithm.JavaSyncUtils.java
License:Open Source License
/** * Updates java code according to the model value for abstract or static modifiers * /*from w ww . jav a2 s .c o m*/ * @author Luiza * @param bd <code>{@link BodyDeclaration}</code> for a class, method or field. * @param isTrue value for the modifier * @param modifier flag indicating the modifier to update. * This should be one of the predefined flags: * <ul> * <li>{@link #MODIFIER_ABSTRACT}</li> * <li>{@link #MODIFIER_STATIC}</li> * </ul> * @flowerModelElementId _zVs8cJiOEd6aNMdNFvR5WQ */ @SuppressWarnings("unchecked") public static void updateModifierFromModelToJavaClass(BodyDeclaration bd, boolean isTrue, String modifier) { ModifierKeyword javaModifierFlag = null; ModifierKeyword modelModifierFlag = null; boolean isForAbstractModif = modifier.equals(MODIFIER_ABSTRACT); boolean isForStaticModif = modifier.equals(MODIFIER_STATIC); boolean isForFinalModif = modifier.equals(MODIFIER_FINAL); if (isForAbstractModif) { javaModifierFlag = Modifier.isAbstract(bd.getModifiers()) ? ModifierKeyword.ABSTRACT_KEYWORD : null; modelModifierFlag = isTrue ? ModifierKeyword.ABSTRACT_KEYWORD : null; } else if (isForStaticModif) { javaModifierFlag = Modifier.isStatic(bd.getModifiers()) ? ModifierKeyword.STATIC_KEYWORD : null; modelModifierFlag = isTrue ? ModifierKeyword.STATIC_KEYWORD : null; } else if (isForFinalModif) { javaModifierFlag = Modifier.isFinal(bd.getModifiers()) ? ModifierKeyword.FINAL_KEYWORD : null; modelModifierFlag = isTrue ? ModifierKeyword.FINAL_KEYWORD : null; } else throw new IllegalArgumentException( "updateModifierFromModelToJavaClass - can't update java code for modifier " + modifier); //if there are differences between the model and the java file if (modelModifierFlag != javaModifierFlag) { //if this modifier has been set before find it and remove it if (javaModifierFlag != null) { //Modifier toRemove = null; /* * we use bd.modifiers() instead of bd.getModifiers(), which computes a bit-wise integer consisting in all the modifier values * because it also iterates over the modifiers and method bd.setModifiers(modifiers) is deprecated */ for (Iterator<Modifier> it = bd.modifiers().iterator(); it.hasNext();) { Modifier modif = it.next(); if (isForAbstractModif && modif.isAbstract()) { it.remove(); break; } else if (isForStaticModif && modif.isStatic()) { it.remove(); break; } else if (isForFinalModif && modif.isFinal()) { it.remove(); break; } } //bd.modifiers().remove(toRemove); } // add the new modifier value if changes have been made in the model if (modelModifierFlag != null) { Modifier newModif = bd.getAST().newModifier(modelModifierFlag); bd.modifiers().add(newModif); } } }
From source file:com.facebook.buck.jvm.java.JavaFileParser.java
License:Apache License
public JavaFileFeatures extractFeaturesFromJavaCode(String code) { // For now, we will harcode this. Ultimately, we probably want to make this configurable via // .buckconfig. For example, the Buck project itself is diligent about disallowing wildcard // imports, but the one exception is the Java code generated via Thrift in src-gen. boolean shouldThrowForUnsupportedWildcardImport = false; AtomicBoolean isPoisonedByUnsupportedWildcardImport = new AtomicBoolean(false); CompilationUnit compilationUnit = makeCompilationUnitFromSource(code); ImmutableSortedSet.Builder<String> providedSymbols = ImmutableSortedSet.naturalOrder(); ImmutableSortedSet.Builder<String> requiredSymbols = ImmutableSortedSet.naturalOrder(); ImmutableSortedSet.Builder<String> exportedSymbols = ImmutableSortedSet.naturalOrder(); ImmutableSortedSet.Builder<String> requiredSymbolsFromExplicitImports = ImmutableSortedSet.naturalOrder(); compilationUnit.accept(new ASTVisitor() { @Nullable//www . ja va 2 s .c om private String packageName; /** Maps simple name to fully-qualified name. */ private Map<String, String> simpleImportedTypes = new HashMap<>(); /** * Maps wildcard import prefixes, such as {@code "java.util"} to the types in the * respective package if a wildcard import such as {@code import java.util.*} is used. */ private Map<String, ImmutableSet<String>> wildcardImports = new HashMap<>(); @Override public boolean visit(PackageDeclaration node) { Preconditions.checkState(packageName == null, "There should be at most one package declaration"); packageName = node.getName().getFullyQualifiedName(); return false; } // providedSymbols @Override public boolean visit(TypeDeclaration node) { // Local classes can be declared inside of methods. Skip over these. if (node.getParent() instanceof TypeDeclarationStatement) { return true; } String fullyQualifiedName = getFullyQualifiedTypeName(node); if (fullyQualifiedName != null) { providedSymbols.add(fullyQualifiedName); } @SuppressWarnings("unchecked") List<Type> interfaceTypes = node.superInterfaceTypes(); for (Type interfaceType : interfaceTypes) { tryAddType(interfaceType, DependencyType.EXPORTED); } Type superclassType = node.getSuperclassType(); if (superclassType != null) { tryAddType(superclassType, DependencyType.EXPORTED); } return true; } @Override public boolean visit(EnumDeclaration node) { String fullyQualifiedName = getFullyQualifiedTypeName(node); if (fullyQualifiedName != null) { providedSymbols.add(fullyQualifiedName); } return true; } @Override public boolean visit(AnnotationTypeDeclaration node) { String fullyQualifiedName = getFullyQualifiedTypeName(node); if (fullyQualifiedName != null) { providedSymbols.add(fullyQualifiedName); } return true; } // requiredSymbols /** * Uses heuristics to try to figure out what type of QualifiedName this is. Returns a * non-null value if this is believed to be a reference that qualifies as a "required * symbol" relationship. */ @Override public boolean visit(QualifiedName node) { QualifiedName ancestor = findMostQualifiedAncestor(node); ASTNode parent = ancestor.getParent(); if (!(parent instanceof PackageDeclaration) && !(parent instanceof ImportDeclaration)) { String symbol = ancestor.getFullyQualifiedName(); // If it does not start with an uppercase letter, it is probably because it is a // property lookup. if (CharMatcher.javaUpperCase().matches(symbol.charAt(0))) { addTypeFromDotDelimitedSequence(symbol, DependencyType.REQUIRED); } } return false; } /** * @param expr could be "Example", "Example.field", "com.example.Example". Note it could * also be a built-in type, such as "java.lang.Integer", in which case it will not be * added to the set of required symbols. */ private void addTypeFromDotDelimitedSequence(String expr, DependencyType dependencyType) { // At this point, symbol could be `System.out`. We want to reduce it to `System` and // then check it against JAVA_LANG_TYPES. if (startsWithUppercaseChar(expr)) { int index = expr.indexOf('.'); if (index >= 0) { String leftmostComponent = expr.substring(0, index); if (JAVA_LANG_TYPES.contains(leftmostComponent)) { return; } } } expr = qualifyWithPackageNameIfNecessary(expr); addSymbol(expr, dependencyType); } @Override public boolean visit(ImportDeclaration node) { String fullyQualifiedName = node.getName().getFullyQualifiedName(); // Apparently, "on demand" means "uses a wildcard," such as "import java.util.*". // Although we can choose to prohibit these in our own code, it is much harder to // enforce for third-party code. As such, we will tolerate these for some of the common // cases. if (node.isOnDemand()) { ImmutableSet<String> value = SUPPORTED_WILDCARD_IMPORTS.get(fullyQualifiedName); if (value != null) { wildcardImports.put(fullyQualifiedName, value); return false; } else if (shouldThrowForUnsupportedWildcardImport) { throw new RuntimeException(String.format( "Use of wildcard 'import %s.*' makes it impossible to statically determine " + "required symbols in this file. Please enumerate explicit imports.", fullyQualifiedName)); } else { isPoisonedByUnsupportedWildcardImport.set(true); return false; } } // Only worry about the dependency on the enclosing type. Optional<String> simpleName = getSimpleNameFromFullyQualifiedName(fullyQualifiedName); if (simpleName.isPresent()) { String name = simpleName.get(); int index = fullyQualifiedName.indexOf("." + name); String enclosingType = fullyQualifiedName.substring(0, index + name.length() + 1); requiredSymbolsFromExplicitImports.add(enclosingType); simpleImportedTypes.put(name, enclosingType); } else { LOG.warn("Suspicious import lacks obvious enclosing type: %s", fullyQualifiedName); // The one example we have seen of this in the wild is // "org.whispersystems.curve25519.java.curve_sigs". In practice, we still need to add // it as a required symbol in this case. requiredSymbols.add(fullyQualifiedName); } return false; } @Override public boolean visit(MethodInvocation node) { if (node.getExpression() == null) { return true; } String receiver = node.getExpression().toString(); if (looksLikeAType(receiver)) { addTypeFromDotDelimitedSequence(receiver, DependencyType.REQUIRED); } return true; } /** An annotation on a member with zero arguments. */ @Override public boolean visit(MarkerAnnotation node) { DependencyType dependencyType = findDependencyTypeForAnnotation(node); addSimpleTypeName(node.getTypeName(), dependencyType); return true; } /** An annotation on a member with named arguments. */ @Override public boolean visit(NormalAnnotation node) { DependencyType dependencyType = findDependencyTypeForAnnotation(node); addSimpleTypeName(node.getTypeName(), dependencyType); return true; } /** An annotation on a member with a single, unnamed argument. */ @Override public boolean visit(SingleMemberAnnotation node) { DependencyType dependencyType = findDependencyTypeForAnnotation(node); addSimpleTypeName(node.getTypeName(), dependencyType); return true; } private DependencyType findDependencyTypeForAnnotation(Annotation annotation) { ASTNode parentNode = annotation.getParent(); if (parentNode == null) { return DependencyType.REQUIRED; } if (parentNode instanceof BodyDeclaration) { // Note that BodyDeclaration is an abstract class. Its subclasses are things like // FieldDeclaration and MethodDeclaration. We want to be sure that an annotation on // any non-private declaration is considered an exported symbol. BodyDeclaration declaration = (BodyDeclaration) parentNode; int modifiers = declaration.getModifiers(); if ((modifiers & Modifier.PRIVATE) == 0) { return DependencyType.EXPORTED; } } return DependencyType.REQUIRED; } @Override public boolean visit(SimpleType node) { // This method is responsible for finding the overwhelming majority of the required // symbols in the AST. tryAddType(node, DependencyType.REQUIRED); return true; } // exportedSymbols @Override public boolean visit(MethodDeclaration node) { // Types from private method signatures need not be exported. if ((node.getModifiers() & Modifier.PRIVATE) != 0) { return true; } Type returnType = node.getReturnType2(); if (returnType != null) { tryAddType(returnType, DependencyType.EXPORTED); } @SuppressWarnings("unchecked") List<SingleVariableDeclaration> params = node.parameters(); for (SingleVariableDeclaration decl : params) { tryAddType(decl.getType(), DependencyType.EXPORTED); } @SuppressWarnings("unchecked") List<Type> exceptions = node.thrownExceptionTypes(); for (Type exception : exceptions) { tryAddType(exception, DependencyType.EXPORTED); } return true; } @Override public boolean visit(FieldDeclaration node) { // Types from private fields need not be exported. if ((node.getModifiers() & Modifier.PRIVATE) == 0) { tryAddType(node.getType(), DependencyType.EXPORTED); } return true; } private void tryAddType(Type type, DependencyType dependencyType) { if (type.isSimpleType()) { SimpleType simpleType = (SimpleType) type; Name simpleTypeName = simpleType.getName(); String simpleName = simpleTypeName.toString(); // For a Type such as IExample<T>, both "IExample" and "T" will be submitted here as // simple types. As such, we use this imperfect heuristic to filter out "T" from being // added. Note that this will erroneously exclude "URI". In practice, this should // generally be OK. For example, assuming "URI" is also imported, then at least it // will end up in the set of required symbols. To this end, we perform a second check // for "all caps" types to see if there is a corresponding import and if it should be // exported rather than simply required. if (!CharMatcher.javaUpperCase().matchesAllOf(simpleName) || (dependencyType == DependencyType.EXPORTED && simpleImportedTypes.containsKey(simpleName))) { addSimpleTypeName(simpleTypeName, dependencyType); } } else if (type.isArrayType()) { ArrayType arrayType = (ArrayType) type; tryAddType(arrayType.getElementType(), dependencyType); } else if (type.isParameterizedType()) { ParameterizedType parameterizedType = (ParameterizedType) type; tryAddType(parameterizedType.getType(), dependencyType); @SuppressWarnings("unchecked") List<Type> argTypes = parameterizedType.typeArguments(); for (Type argType : argTypes) { tryAddType(argType, dependencyType); } } } private void addSimpleTypeName(Name simpleTypeName, DependencyType dependencyType) { String simpleName = simpleTypeName.toString(); if (JAVA_LANG_TYPES.contains(simpleName)) { return; } String fullyQualifiedNameForSimpleName = simpleImportedTypes.get(simpleName); if (fullyQualifiedNameForSimpleName != null) { // May need to promote from required to exported in this case. if (dependencyType == DependencyType.EXPORTED) { addSymbol(fullyQualifiedNameForSimpleName, DependencyType.EXPORTED); } return; } // For well-behaved source code, this will always be empty, so don't even bother to // create the iterator most of the time. if (!wildcardImports.isEmpty()) { for (Map.Entry<String, ImmutableSet<String>> entry : wildcardImports.entrySet()) { Set<String> types = entry.getValue(); if (types.contains(simpleName)) { String packageName = entry.getKey(); addSymbol(packageName + "." + simpleName, dependencyType); return; } } } String symbol = simpleTypeName.getFullyQualifiedName(); symbol = qualifyWithPackageNameIfNecessary(symbol); addSymbol(symbol, dependencyType); } private void addSymbol(String symbol, DependencyType dependencyType) { ((dependencyType == DependencyType.REQUIRED) ? requiredSymbols : exportedSymbols).add(symbol); } private String qualifyWithPackageNameIfNecessary(String symbol) { if (!startsWithUppercaseChar(symbol)) { return symbol; } // If the symbol starts with a capital letter, then we assume that it is a reference to // a type in the same package. int index = symbol.indexOf('.'); if (index >= 0) { symbol = symbol.substring(0, index); } if (packageName != null) { symbol = packageName + "." + symbol; } return symbol; } }); // TODO(mbolin): Special treatment for exportedSymbols when poisoned by wildcard import. ImmutableSortedSet<String> totalExportedSymbols = exportedSymbols.build(); // If we were poisoned by an unsupported wildcard import, then we should rely exclusively on // the explicit imports to determine the required symbols. Set<String> totalRequiredSymbols = new HashSet<>(); if (isPoisonedByUnsupportedWildcardImport.get()) { totalRequiredSymbols.addAll(requiredSymbolsFromExplicitImports.build()); } else { totalRequiredSymbols.addAll(requiredSymbolsFromExplicitImports.build()); totalRequiredSymbols.addAll(requiredSymbols.build()); } // Make sure that required and exported symbols are disjoint sets. totalRequiredSymbols.removeAll(totalExportedSymbols); return new JavaFileFeatures(providedSymbols.build(), ImmutableSortedSet.copyOf(totalRequiredSymbols), totalExportedSymbols); }
From source file:com.google.devtools.j2cpp.translate.Rewriter.java
License:Open Source License
/** * Remove private serialization methods and fields; since Java serialization * isn't supported, they only take up space. The list of methods is taken * from the java.io.Serialization javadoc comments. */// ww w . j a va 2 s. com private void removeSerialization(List<BodyDeclaration> members) { for (Iterator<BodyDeclaration> iterator = members.iterator(); iterator.hasNext();) { BodyDeclaration member = iterator.next(); int mods = member.getModifiers(); if (member instanceof MethodDeclaration) { IMethodBinding binding = Types.getMethodBinding(member); String name = binding.getName(); ITypeBinding[] parameterTypes = binding.getParameterTypes(); ITypeBinding returnType = binding.getReturnType(); if (name.equals("readObject") && Modifier.isPrivate(mods) && parameterTypes.length == 1 && parameterTypes[0].getQualifiedName().equals("java.io.ObjectInputStream") && returnType.getBinaryName().equals("V")) { iterator.remove(); continue; } if (name.equals("writeObject") && Modifier.isPrivate(mods) && parameterTypes.length == 1 && parameterTypes[0].getQualifiedName().equals("java.io.ObjectOutputStream") && returnType.getBinaryName().equals("V")) { iterator.remove(); continue; } if (name.equals("readObjectNoData") && Modifier.isPrivate(mods) && parameterTypes.length == 0 && returnType.getBinaryName().equals("V")) { iterator.remove(); continue; } if ((name.equals("readResolve") || name.equals("writeResolve")) && Modifier.isPrivate(mods) && parameterTypes.length == 0 && returnType.getQualifiedName().equals("java.lang.Object")) { iterator.remove(); continue; } } else if (member instanceof FieldDeclaration) { FieldDeclaration field = (FieldDeclaration) member; Type type = field.getType(); VariableDeclarationFragment var = (VariableDeclarationFragment) field.fragments().get(0); if (var.getName().getIdentifier().equals("serialVersionUID") && type.isPrimitiveType() && ((PrimitiveType) type).getPrimitiveTypeCode() == PrimitiveType.LONG && Modifier.isPrivate(mods) && Modifier.isStatic(mods)) { iterator.remove(); continue; } } } }
From source file:com.servoy.eclipse.docgenerator.metamodel.MemberMetaModel.java
License:Open Source License
protected MemberMetaModel(String className, String name, BodyDeclaration astNode) { this.className = className; this.name = name; Visibility vis = Visibility.Protected; for (Object o : astNode.modifiers()) { if (o instanceof Modifier) { Modifier mod = (Modifier) o; if (mod.isPrivate()) vis = Visibility.Private; else if (mod.isPublic()) vis = Visibility.Public; }/*from w w w . j ava2 s. c om*/ } visibility = vis; statc = Modifier.isStatic(astNode.getModifiers()); duplicate = false; }
From source file:de.akra.idocit.java.services.JavaInterfaceParser.java
License:Apache License
/** * Convert an {@link AbstractTypeDeclaration} to a {@link JavaInterface}. * /*from w w w .j a va2 s . c om*/ * @param parent * The parent {@link SignatureElement}. * @param absTypeDeclaration * The {@link AbstractTypeDeclaration} to process. * @param category * The category for the {@link JavaInterface}. * @return a new {@link JavaInterface}. * @throws ParserConfigurationException * @throws IOException * @throws SAXException * @see AbstractTypeDeclaration */ private JavaInterface processAbstractTypeDeclaration(final SignatureElement parent, final AbstractTypeDeclaration absTypeDeclaration, final String category, final AbsJavadocParser parser) throws SAXException, IOException, ParserConfigurationException, ParsingException { final JavaInterface jInterface = new JavaInterface(parent, category, Numerus.SINGULAR); jInterface.setIdentifier(absTypeDeclaration.getName().getIdentifier()); jInterface.setQualifiedIdentifier(absTypeDeclaration.getName().getFullyQualifiedName()); jInterface.setRefToASTNode(absTypeDeclaration); final Javadoc javadoc = absTypeDeclaration.getJavadoc(); final List<Addressee> addressees = ServiceManager.getInstance().getPersistenceService() .loadConfiguredAddressees(); final List<ThematicRole> roles = ServiceManager.getInstance().getPersistenceService().loadThematicRoles(); List<Documentation> docs = parser.parseIDocItJavadoc(javadoc, addressees, roles, null); if (docs.isEmpty()) { docs = parser.convertExistingJavadoc(javadoc); } jInterface.setDocumentations(docs); final List<ThematicRole> knownRoles = ServiceManager.getInstance().getPersistenceService() .loadThematicRoles(); final List<TagElement> additionalTags = parser.findAdditionalTags(javadoc, knownRoles); jInterface.setAdditionalTags(additionalTags); @SuppressWarnings("unchecked") final List<BodyDeclaration> bodyDeclarations = (List<BodyDeclaration>) absTypeDeclaration .bodyDeclarations(); List<Interface> innerInterface = Collections.emptyList(); List<Operation> operations = Collections.emptyList(); for (final BodyDeclaration bodyDec : bodyDeclarations) { // only public elements are processed. In Java interfaces everything is // public. if (ReflectionHelper.isPublic(bodyDec.getModifiers()) || Constants.CATEGORY_INTERFACE.equals(category)) { switch (bodyDec.getNodeType()) { case ASTNode.TYPE_DECLARATION: { if (innerInterface == Collections.EMPTY_LIST) { innerInterface = new ArrayList<Interface>(SignatureElement.DEFAULT_ARRAY_SIZE); } final TypeDeclaration typeDec = (TypeDeclaration) bodyDec; innerInterface.add(processTypeDeclaration(jInterface, typeDec, parser)); break; } case ASTNode.ENUM_DECLARATION: { if (innerInterface == Collections.EMPTY_LIST) { innerInterface = new ArrayList<Interface>(SignatureElement.DEFAULT_ARRAY_SIZE); } final EnumDeclaration enumDec = (EnumDeclaration) bodyDec; innerInterface.add(processEnumDeclaration(jInterface, enumDec, parser)); break; } case ASTNode.METHOD_DECLARATION: { if (operations == Collections.EMPTY_LIST) { // init with number of all declarations for fields, methods, // enumerations, classes etc. to avoid resizing of the array operations = new ArrayList<Operation>(bodyDeclarations.size()); } final MethodDeclaration methodDec = (MethodDeclaration) bodyDec; operations.add(processMethodDeclaration(jInterface, methodDec, parser, knownRoles)); break; } default: { // Do nothing! logger.info("Nodetype of ASTNode is " + bodyDec.getNodeType()); } } } } jInterface.setInnerInterfaces(innerInterface); jInterface.setOperations(operations); return jInterface; }