com.github.javaparser.ast.comments.Comment Java Examples

private static boolean containsModifiedComments(CompilationUnit originalCU, CompilationUnit mutatedCU) {
    // We assume getAllContainedComments() preserves the order of comments
    Comment[] originalComments = originalCU.getAllContainedComments().toArray(new Comment[] {});
    Comment[] mutatedComments = mutatedCU.getAllContainedComments().toArray(new Comment[] {});
    if (originalComments.length != mutatedComments.length) {
        // added comments triggers validation
        return true;
    }
    // We cannot use equality here because inserting empty lines will change the lineStart attribute of the Comment node.
    for (int i = 0; i < originalComments.length; i++) {
        // Somehow the mutated comments contain char(13) '\r' in addition to '\n'
        // TODO Where those come from? CodeMirror?
        if ( ! originalComments[i].toString().replaceAll("\\r","").equals(mutatedComments[i].toString().replaceAll("\\r","")) ) {
            return true;
        }
    }

    return false;
}
 

private static String getAllCommentsText(BodyDeclaration declaration) {
    List<Comment> allContainedComments = declaration.getAllContainedComments();
    StringBuffer sb = new StringBuffer();
    boolean append =false;
    Optional<Comment> commentOp = declaration.getComment();
    if (commentOp.isPresent()){
        sb.append(commentOp.get().getContent()) ;
        append=true;
    }
    for (Comment comment : allContainedComments) {
        if (append){
            sb.append(" ");
        }
        sb.append(comment.toString());
        append=true;
    }
    String oldCommentText = sb.toString();
    return oldCommentText;
}
 

private void syncHeader(Comment comment) {
    String value = comment.toString();
    if (javaClass.getRootElement()
            .getSnippets(BEFORE_PACKAGE)
            .stream()
            .filter(snip -> {
                Optional<CompilationUnit> parsed = new JavaParser().parse(snip.getValue()).getResult();
                return (parsed.isPresent()&& compareNonWhitespaces(parsed.get().toString(), value))
                        || compareNonWhitespaces(snip.getValue(), value);
            })
            .findAny()
            .isPresent()) {
        return;
    }
    if (javaClass.getSnippets(BEFORE_PACKAGE)
            .stream()
            .filter(snip -> compareNonWhitespaces(snip.getValue(), value))
            .findAny()
            .isPresent()) {
        return;
    }
    javaClass.addRuntimeSnippet(new ClassSnippet(value, BEFORE_PACKAGE));
}
 

private void printOrphanCommentsEnding(final Node node) {
    List<Node> everything = new LinkedList<>();
    everything.addAll(node.getChildNodes());
    sortByBeginPosition(everything);
    if (everything.isEmpty()) {
        return;
    }

    int commentsAtEnd = 0;
    boolean findingComments = true;
    while (findingComments && commentsAtEnd < everything.size()) {
        Node last = everything.get(everything.size() - 1 - commentsAtEnd);
        findingComments = (last instanceof Comment);
        if (findingComments) {
            commentsAtEnd++;
        }
    }
    for (int i = 0; i < commentsAtEnd; i++) {
        everything.get(everything.size() - commentsAtEnd + i).accept(this, null);
    }
}
 

public static String mergeContent(CompilationUnit one, CompilationUnit two) throws Exception {

        // 包声明不同，返回null
        if (!one.getPackage().equals(two.getPackage())) return null;

        CompilationUnit cu = new CompilationUnit();

        // add package declaration to the compilation unit
        PackageDeclaration pd = new PackageDeclaration();
        pd.setName(one.getPackage().getName());
        cu.setPackage(pd);

        // check and merge file comment;
        Comment fileComment = mergeSelective(one.getComment(), two.getComment());
        cu.setComment(fileComment);

        // check and merge imports
        List<ImportDeclaration> ids = mergeListNoDuplicate(one.getImports(), two.getImports());
        cu.setImports(ids);

        // check and merge Types
        List<TypeDeclaration> types = mergeTypes(one.getTypes(), two.getTypes());
        cu.setTypes(types);

        return cu.toString();
    }
 

@Override
public void visit(FieldDeclaration n, Void arg) {
    if (n.isFinal() || n.isStatic()) {
        return;
    }
    NodeList<VariableDeclarator> nodeList = n.getVariables();
    for (VariableDeclarator declarator : nodeList) {
        FieldInfoDto fieldInfoDto = new FieldInfoDto();
        fieldInfoDto.setDataName(declarator.getNameAsString());
        fieldInfoDto.setFieldClass(declarator.getType().asString());

        Optional<Comment> commentOptional = n.getComment();
        if (commentOptional.isPresent()) {
            String commentContent = commentOptional.get().getContent();
            commentContent = commentContent.replaceAll("\\*", "");
            fieldInfoDto.setComment(commentContent.trim());
        } else {
            fieldInfoDto.setComment(fieldInfoDto.getDataName());
        }
        sourceCodeDto.addField(fieldInfoDto);
    }
    sourceCodeDto.addFieldDeclaration(n);
    super.visit(n, arg);
}
 

private String retrieveComments(Node n) {
    // retrieve the comments separately
    String commentStr;
    List<Comment> comments = n.getAllContainedComments();
    commentStr = concatComments(comments);
    commentStr += concatComments(n.getOrphanComments());
    if (n.getComment().isPresent()) {
        commentStr += "/**" + n.getComment().get().getContent() + "*/";
    }
    return commentStr;
}
 

protected boolean isCommentPresent(Node node, String wanted) {
    Optional<Comment> maybeComment = node.getComment();
    if (maybeComment.isPresent()) {
        Comment comment = maybeComment.get();
        String content = comment.getContent().trim();
        if (wanted.equals(content)) {
            return true;
        }
    }
    return false;
}
 

static Stream<AnnotationExplorer> getAnnotationAttributes(AnnotationExpr annotationExpr, String attributeName) {
    Stream<AnnotationExplorer> annotations = Stream.of();
    Optional<Expression> expressionOpt = getAttribute(annotationExpr, attributeName);
    if (expressionOpt.isPresent()) {
        Expression expression = expressionOpt.get();
        if (expression.isAnnotationExpr()) {
            annotations = expressionOpt
                    .map(exp -> exp.asAnnotationExpr())
                    .map(AnnotationExplorer::new)
                    .map(exp -> Stream.of(exp))
                    .orElse(Stream.of());
        } else if (expression.isArrayInitializerExpr()) {
            List<AnnotationExplorer> values = new ArrayList<>();
            List<Node> nodes = expression.asArrayInitializerExpr().getChildNodes();
            for (Node node : nodes) {
                if (node instanceof AnnotationExpr) {
                    AnnotationExplorer annotation = new AnnotationExplorer((AnnotationExpr) node);
                    values.add(annotation);
                } else if (node instanceof Comment) {
                    //ignore
                } else {
                    throw new UnsupportedOperationException();
                }
            }
            annotations = values.stream();
        } else {
            throw new UnsupportedOperationException();
        }

    }
    return annotations;
}
 

private void syncJavadoc(Comment comment) {
    String value = comment.toString();
    if (javaClass.getRootElement()
            .getSnippets(TYPE_JAVADOC)
            .stream()
            .filter(snip -> compareNonWhitespaces(snip.getValue(), value))
            .findAny()
            .isPresent()) {
        return;
    }
    if (javaClass.getSnippets(TYPE_JAVADOC)
            .stream()
            .filter(snip -> compareNonWhitespaces(snip.getValue(), value))
            .findAny()
            .isPresent()) {
        return;
    }
    if (javaClass.getRootElement()
            .getSnippets(BEFORE_CLASS)
            .stream()
            .filter(snip -> compareNonWhitespaces(snip.getValue(), value))
            .findAny()
            .isPresent()) {
        return;
    }
    if (javaClass.getSnippets(BEFORE_CLASS)
            .stream()
            .filter(snip -> compareNonWhitespaces(snip.getValue(), value))
            .findAny()
            .isPresent()) {
        return;
    }
    if (javaClass.getDescription() == null || !value.contains(javaClass.getDescription())) {
        javaClass.addRuntimeSnippet(new ClassSnippet(value, TYPE_JAVADOC));
    }
}
 

private void syncJavadoc(Optional<Comment> commentOpt, AttributeSnippetLocationType locationType) {
    if (commentOpt.isPresent()
            && attribute.getSnippets(locationType).isEmpty()
            && attribute.getJavaClass().getSnippets().isEmpty()) {
        Comment comment = commentOpt.get();
        AttributeSnippet attributeSnippet = new AttributeSnippet();
        attributeSnippet.setLocationType(locationType);
        attributeSnippet.setValue(String.format("%" + comment.getBegin().get().column + "s%s", "", comment.toString()));
        if (attribute.getDescription() == null
                || !attributeSnippet.getValue().contains(attribute.getDescription())) {
            attribute.addRuntimeSnippet(attributeSnippet);
        }
    }
}
 

protected <T extends Node> void mergeOrphanComments(T first, T second, T third) {
  List<Comment> comments = mergeCollections(first.getOrphanComments(), second.getOrphanComments());
  if (comments != null && !comments.isEmpty()) {
    for (Comment comment : comments) {
      third.addOrphanComment(comment);
    }
  }
}
 

@Override
public void visit(MethodDeclaration method, Void arg) {
    method.getComment()
            .filter(Comment::isJavadocComment)
            .map(this::toJavaDoc)
            .ifPresent(c -> recordMethodComment(c, method));
    super.visit(method, arg);
}
 

@Override
public void visit(FieldDeclaration field, Void arg) {
    field.getComment()
            .filter(Comment::isJavadocComment)
            .map(this::toJavaDoc)
            .ifPresent(c -> createFieldComment(c, field));
    super.visit(field, arg);
}
 

@Override
public void visit(ClassOrInterfaceDeclaration classOrInterface, Void arg) {
    className = calculateClassName(classOrInterface);

    classOrInterface.getComment()
            .filter(Comment::isJavadocComment)
            .map(this::toJavaDoc)
            .ifPresent(this::recordClassComment);

    super.visit(classOrInterface, arg);
}
 

private String concatComments(List<Comment> comments) {
    String com = "";
    for (Comment c: comments) {
        com += "/*" + c.getContent() + "*/";
    }
    return com;
}
 

private static void convertAndAddImport(LinkedHashSet<Import> allImports, List<Node> thisImport,
    String eol) {
  boolean isStatic = false;
  String importItem = null;
  String prefix = "";
  String suffix = "";
  for (Node n : thisImport) {
    if (n instanceof Comment) {
      if (importItem == null) {
        prefix += n.toString();
      } else {
        suffix += n.toString();
      }
    }
    if (n instanceof ImportDeclaration) {
      ImportDeclaration i = (ImportDeclaration) n;
      isStatic = i.isStatic();
      importItem = i.getName().asString() + (i.isAsterisk() ? ".*" : "");
    }
  }
  suffix = suffix.trim();
  if (!suffix.isEmpty()) {
    suffix = " " + suffix;
  }
  Import imp = new Import(isStatic, importItem, prefix.trim(), suffix, eol);
  Iterator<Import> iter = allImports.iterator();
  // this de-duplication can probably be made more efficient by doing it all at the end
  while (iter.hasNext()) {
    Import candidate = iter.next(); // potential duplicate
    if (candidate.isDuplicatedBy(imp)) {
      iter.remove();
      imp = candidate.combineWith(imp);
    }
  }
  allImports.add(imp);
}
 

private static Set<Import> convertImportSection(List<Node> importSectionNodes, String eol) {
  List<Comment> recentComments = new ArrayList<>();
  LinkedHashSet<Import> allImports = new LinkedHashSet<>(importSectionNodes.size() / 2);
  for (Node node : importSectionNodes) {
    if (node instanceof Comment) {
      recentComments.add((Comment) node);
    } else if (node instanceof ImportDeclaration) {
      List<Node> thisImport = new ArrayList<>(2);
      ImportDeclaration impDecl = (ImportDeclaration) node;
      thisImport.addAll(recentComments);

      Optional<Comment> impComment = impDecl.getComment();
      if (impComment.isPresent()) {
        Comment c = impComment.get();
        if (c.getBegin().get().isBefore(impDecl.getBegin().get())) {
          thisImport.add(c);
          thisImport.add(impDecl);
        } else {
          thisImport.add(impDecl);
          thisImport.add(c);
        }
      } else {
        thisImport.add(impDecl);
      }

      recentComments.clear();
      convertAndAddImport(allImports, thisImport, eol);
    } else {
      throw new IllegalStateException("Unknown node: " + node);
    }
  }
  if (!recentComments.isEmpty()) {
    throw new IllegalStateException(
        "Unexpectedly found more orphaned comments: " + recentComments);
  }
  return allImports;
}
 

/**
 * 解析注释
 * @param comment
 */
public void accept(Comment comment) {
    if (!comment.isJavadocComment()) {
        this.setComment(comment.getContent());
        return;
    }
    Javadoc javadoc = comment.asJavadocComment().parse();
    this.setComment(CommentHelper.getDescription(javadoc.getDescription()));

    javadoc.getBlockTags().forEach(this::parse);
}
 

/**
 * 解析属性的注释
 * @param it
 * @return
 */
public static Optional<Comment> getComment(ResolvedFieldDeclaration it) {
    if (it instanceof JavaParserFieldDeclaration) {
        FieldDeclaration wrappedNode = ((JavaParserFieldDeclaration) it).getWrappedNode();
        return wrappedNode.getComment();
    }
    if (it instanceof JavaParserClassDeclaration) {
        JavaParserClassDeclaration classDeclaration = (JavaParserClassDeclaration) it;
        return classDeclaration.getWrappedNode().getComment();
    }
    return Optional.empty();
}
 

private void printOrphanCommentsBeforeThisChildNode(final Node node) {
    if (node instanceof Comment) return;

    Node parent = node.getParentNode().orElse(null);
    if (parent == null) return;
    List<Node> everything = new LinkedList<>();
    everything.addAll(parent.getChildNodes());
    sortByBeginPosition(everything);
    int positionOfTheChild = -1;
    for (int i = 0; i < everything.size(); i++) {
        if (everything.get(i) == node) positionOfTheChild = i;
    }
    if (positionOfTheChild == -1) {
        throw new AssertionError("I am not a child of my parent.");
    }
    int positionOfPreviousChild = -1;
    for (int i = positionOfTheChild - 1; i >= 0 && positionOfPreviousChild == -1; i--) {
        if (!(everything.get(i) instanceof Comment)) positionOfPreviousChild = i;
    }
    for (int i = positionOfPreviousChild + 1; i < positionOfTheChild; i++) {
        Node nodeToPrint = everything.get(i);
        if (!(nodeToPrint instanceof Comment))
            throw new RuntimeException(
                    "Expected comment, instead " + nodeToPrint.getClass() + ". Position of previous child: "
                            + positionOfPreviousChild + ", position of child " + positionOfTheChild);
        nodeToPrint.accept(this, null);
    }
}
 

@Test
public void test(){
    CompilationUnit compilationUnit = new CompilationUnit();
    ClassOrInterfaceDeclaration myClass = compilationUnit
            .addClass("MyClass")
            .setPublic(true);
    myClass.addField(int.class, "A_CONSTANT", PUBLIC, STATIC);
    myClass.addField(String.class, "name", PRIVATE);
    Comment comment= new JavadocComment();
    comment.setContent("你大爷！");
    myClass.addMethod("helloWorld", PUBLIC).setParameters(NodeList.nodeList()).setComment(comment);
    String code = myClass.toString();
    System.out.println(code);
}
 

@Override
public void visit(EnumDeclaration n, Void arg) {
    sourceCodeDto.setClassName(n.getNameAsString());
    Optional<Comment> commentOptional = n.getComment();
    if (commentOptional.isPresent()) {
        sourceCodeDto.setComment(commentOptional.get().getContent());
    } else {
        sourceCodeDto.setComment(sourceCodeDto.getClassName());
    }
    super.visit(n, arg);
}
 

@Override
public void visit(ClassOrInterfaceDeclaration n, Void arg) {
    if (!n.isPublic()) {
        return;
    }

    sourceCodeDto.setClassName(n.getNameAsString());
    Optional<Comment> commentOptional = n.getComment();
    if (commentOptional.isPresent()) {
        sourceCodeDto.setComment(commentOptional.get().getContent());
    } else {
        sourceCodeDto.setComment(sourceCodeDto.getClassName());
    }
    super.visit(n, arg);
}
 

private Javadoc toJavaDoc(Comment comment) {
    return comment.asJavadocComment().parse();
}
 

/**
 * This method performs the refactoring and returns a commit message.
 *
 * @param issue
 * @param gitConfig
 * @return commitMessage
 * @throws IOException
 * @throws BotRefactoringException
 */
@Override
public String performRefactoring(BotIssue issue, GitConfiguration gitConfig)
		throws IOException, BotRefactoringException {

	// Prepare data
	String path = gitConfig.getRepoFolder() + "/" + issue.getFilePath();

	line = issue.getLine();

	// Read file
	FileInputStream in = new FileInputStream(path);
	CompilationUnit compilationUnit = LexicalPreservingPrinter.setup(StaticJavaParser.parse(in));

	List<Comment> comments = compilationUnit.getAllContainedComments();

	// Keeping track of the start and end line of the commented out code to add it
	// to the output string
	int startLine = line;
	int endLine = -1;

	// Going through all comments and checking if the line matches the one we're
	// looking for
	for (Comment comment : comments) {
		if ((line >= comment.getBegin().get().line) && (line <= comment.getEnd().get().line)) {
			if (comment.isLineComment()) {
				endLine = comment.getEnd().get().line;
				comment.remove();
				// Increase the line variable to find more commented out code lines below
				line++;
			} else if (comment.isBlockComment()) {
				// The comment is a multi-line comment, so we remove the entire thing right away
				startLine = comment.getBegin().get().line;
				endLine = comment.getEnd().get().line;
				comment.remove();
				break;
			} else if (comment.isJavadocComment()) {
				throw new BotRefactoringException(
						"Found a JavaDoc comment at the indicated line. These are not removed.");
			}
		}
	}

	// We never set the endLine variable, which means we found no matching comment
	// for the indicated line
	if (endLine == -1) {
		throw new BotRefactoringException("Commented out code line could not be found"
				+ System.getProperty("line.separator") + "Are you sure that the source code and "
				+ "SonarQube analysis are on the same branch and version?");
	}

	// Printing the output file with JavaParser
	PrintWriter out = new PrintWriter(path);
	out.println(LexicalPreservingPrinter.print(compilationUnit));
	out.close();

	// Return commit message
	return ("Removed " + (endLine - startLine + 1) + " line(s) of commented out code (line " + startLine + "-"
			+ endLine + ")");
}
 

@Override
public void accept(Comment comment) {
    super.accept(comment);
    super.index().ifPresent(this::setIndex);
}
 

private void printJavaComment(final Optional<Comment> javacomment, final Void arg) {
    javacomment.ifPresent(c -> c.accept(this, arg));
}
 

@Test
public void compileFunctionInstantiatingTypeFromJar() throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, IOException {
    Method invoke = compileFunction("use_jar_constructor", new Class[]{String.class}, ImmutableList.of("src/test/resources/jars/javaparser-core-2.2.1.jar"));
    Comment comment = (Comment)invoke.invoke(null, "qwerty");
    assertEquals("qwerty", comment.getContent());
}
 

@Test
public void compileFunctionUsingMethodTypeFromJar() throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, IOException {
    Method invoke = compileFunction("use_jar_method", new Class[]{Comment.class}, ImmutableList.of("src/test/resources/jars/javaparser-core-2.2.1.jar"));
    Comment comment = new LineComment("qwerty");
    assertEquals("qwerty", invoke.invoke(null, comment));
}