@Override public void visit(BlockStmt n, Void arg) { out.println("BlockStmt: " + (extended ? n : n.getStatements().size() + " statements")); super.visit(n, arg); }
private static ClassOrInterfaceType simpleParametricType(String className, String... typeArgs) { NodeList<Type> typeArguments = new NodeList<Type>(); for (String typeArg : typeArgs) { typeArguments.add(classType(typeArg)); } return new ClassOrInterfaceType(null, new SimpleName(className), typeArguments); }
@Override public ResolvedType visit(FieldDeclaration node, Boolean solveLambdas) { if (node.getVariables().size() == 1) { return node.getVariables().get(0).accept(this, solveLambdas); } else { throw new IllegalArgumentException("Cannot resolve the type of a field with multiple variable declarations. Pick one"); } } }
@Override protected int getNumberOfTypes(CompilationUnit compilationUnit) { List<AnnotationExpr> annotations = compilationUnit.getTypes().get(0).getAnnotations(); return annotations.size(); }
private boolean isNullable(FieldDeclaration field) { return field.getAnnotations().stream() .map(AnnotationExpr::getNameAsString) .anyMatch(name -> name.equals("Nullable")); }
val cu = JavaParser.parse(is); new ConfigurationMetadataFieldVisitor(collectedProps, collectedGroups, indexNameWithBrackets, typeName, sourcePath).visit(cu, p); if (!cu.getTypes().isEmpty()) { val decl = ClassOrInterfaceDeclaration.class.cast(cu.getType(0)); for (var i = 0; i < decl.getExtendedTypes().size(); i++) { val parentType = decl.getExtendedTypes().get(i); val instance = ConfigurationMetadataClassSourceLocator.getInstance(); val parentClazz = instance.locatePropertiesClassForType(parentType);
private NodeList<Modifier> getModifiersInCorrectOrder(NodeList<Modifier> modifiers) { NodeList<Modifier> reorderedModifiers = new NodeList<>(); if (modifiers.size() <= 1) { return modifiers; } // Fill enum set with java modifier keywords, assuming that they are in the // correct order EnumSet<Keyword> keywords = EnumSet.noneOf(Keyword.class); for (Modifier modifier : modifiers) { keywords.add(modifier.getKeyword()); } // Reorder modifiers for (Keyword keyword : keywords) { for (Modifier modifier : modifiers) { if (keyword.equals(modifier.getKeyword())) { reorderedModifiers.add(modifier); } } } return reorderedModifiers; }
public static Optional<TypeDeclaration<?>> findType(CompilationUnit cu, String qualifiedName) { if (cu.getTypes().isEmpty()) { return Optional.empty(); } final String typeName = getOuterTypeName(qualifiedName); Optional<TypeDeclaration<?>> type = cu.getTypes().stream().filter((t) -> t.getName().getId().equals(typeName)).findFirst(); final String innerTypeName = getInnerTypeName(qualifiedName); if (type.isPresent() && !innerTypeName.isEmpty()) { return findType(type.get(), innerTypeName); } return type; }
private static void writeClassDeclaration(PrintStream s, ClassOrInterfaceDeclaration c) { s.format("\npublic%s class %s", c.isFinal() ? " final" : "", c.getName()); if (c.getImplementedTypes() != null && !c.getImplementedTypes().isEmpty()) { s.format(" implements"); for (ClassOrInterfaceType iface : c.getImplementedTypes()) { s.append(" " + iface); } } s.append(" {\n"); Preconditions.checkArgument(c.getExtendedTypes().size() == 0); }
@Override public List<ResolvedFieldDeclaration> getAllFields() { List<ResolvedFieldDeclaration> fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); this.getAncestors().forEach(a -> fields.addAll(a.getAllFieldsVisibleToInheritors())); this.wrappedNode.getMembers().stream().filter(m -> m instanceof FieldDeclaration).forEach(m -> { FieldDeclaration fd = (FieldDeclaration)m; fd.getVariables().forEach(v -> fields.add(new JavaParserFieldDeclaration(v, typeSolver))); }); return fields; }
/** * Generates something like * <code>private static final AtomicLongFieldUpdater<MpmcAtomicArrayQueueProducerIndexField> P_INDEX_UPDATER = AtomicLongFieldUpdater.newUpdater(MpmcAtomicArrayQueueProducerIndexField.class, "producerIndex");</code> * * @param type * @param name * @param initializer * @param modifiers * @return */ private static FieldDeclaration fieldDeclarationWithInitialiser(Type type, String name, Expression initializer, Modifier... modifiers) { FieldDeclaration fieldDeclaration = new FieldDeclaration(); VariableDeclarator variable = new VariableDeclarator(type, name, initializer); fieldDeclaration.getVariables().add(variable); EnumSet<Modifier> modifierSet = EnumSet.copyOf(Arrays.asList(modifiers)); fieldDeclaration.setModifiers(modifierSet); return fieldDeclaration; }
if (field != null) { modifiersInCorrectOrder = getModifiersInCorrectOrder(field.getModifiers()); isModifierListUnchanged = field.getModifiers().equals(modifiersInCorrectOrder); field.setModifiers(new NodeList<Modifier>()); field.setModifiers(modifiersInCorrectOrder); } else if (method != null) { modifiersInCorrectOrder = getModifiersInCorrectOrder(method.getModifiers()); isModifierListUnchanged = method.getModifiers().equals(modifiersInCorrectOrder); method.setModifiers(new NodeList<Modifier>()); method.setModifiers(modifiersInCorrectOrder); } else {
@Override public void visit(final FieldDeclaration field, final ConfigurationMetadataProperty property) { if (field.getVariables().isEmpty()) { throw new IllegalArgumentException("Field " + field + " has no variable definitions"); } val var = field.getVariable(0); if (field.getModifiers().contains(Modifier.STATIC)) { LOGGER.debug("Field [{}] is static and will be ignored for metadata generation", var.getNameAsString()); return; } if (field.getJavadoc().isEmpty()) { LOGGER.error("Field [{}] has no Javadoc defined", field); } val creator = new ConfigurationMetadataPropertyCreator(indexNameWithBrackets, properties, groups, parentClass); val prop = creator.createConfigurationProperty(field, property.getName()); processNestedClassOrInterfaceTypeIfNeeded(field, prop); }
private Collection<Member> gatherFinalMembers(List<Member> members, CompilationUnit cu) { Map<String, Member> memberMap = new LinkedHashMap<>(); for (Member member : members) { String key = member.getKey(); if (!memberMap.containsKey(key)) { memberMap.put(key, member); } else { BodyDeclaration<?> copy = member.getDeclaration().clone(); if (copy instanceof ConstructorDeclaration) { ((ConstructorDeclaration) copy).setBody(JavaParser.parseBlock("{}")); ((ConstructorDeclaration) copy).setComment(null); } else if (copy instanceof MethodDeclaration) { ((MethodDeclaration) copy).setBody(null); ((MethodDeclaration) copy).setComment(null); } else if (copy instanceof FieldDeclaration) { ((FieldDeclaration) copy).getVariable(0).setInitializer((Expression) null); ((FieldDeclaration) copy).setComment(null); } copy.setAnnotations(new NodeList<>()); Logger.getGlobal().warning(String.format("Suppressing already-present generated member in type %s: %s", cu.getType(0).getNameAsString(), copy.toString())); } } return memberMap.values(); }
@Override public ResolvedType visit(FieldDeclaration node, Boolean solveLambdas) { if (node.getVariables().size() == 1) { return node.getVariables().get(0).accept(this, solveLambdas); } else { throw new IllegalArgumentException("Cannot resolve the type of a field with multiple variable declarations. Pick one"); } } }
@Override protected String getTypeName(CompilationUnit compilationUnit, int index) { List<AnnotationExpr> annotations = compilationUnit.getTypes().get(0).getAnnotations(); return annotations.get(index).getNameAsString(); }