Qu'est-ce que JavaParser?

Comme son nom l'indique, une bibliothèque qui analyse le code source Java
Le résultat de l'analyse de la source peut être obtenu sous forme d'arbre de syntaxe abstraite (AST), et le résultat de l'analyse peut être consulté par des méthodes telles que le modèle de visiteur.
Parlant de la bibliothèque d'analyse de source Java, il existe un moyen d'utiliser Eclipse JDT [^ 1] --JDT est principalement destiné aux plug-ins Eclipse, tandis que JavaParser est uniquement destiné à l'analyse de la syntaxe Java.
Étant donné que la bibliothèque requise est un pot (environ 800 Ko), il est facile à installer. --Il semble prendre en charge Java 9
Puisque ʻOptional` est utilisé pour l'API, il ne peut être utilisé qu'avec Java 8 ou supérieur.

Hello World ** Dépendances **

`build.gradle`


dependencies {
    compile 'com.github.javaparser:javaparser-core:3.3.0'
}

La mise en oeuvre

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        try {
            CompilationUnit unit = JavaParser.parse(source);
            System.out.println("***********************************************");
            System.out.println(unit);
            System.out.println("***********************************************");
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

***********************************************
package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        try {
            CompilationUnit unit = JavaParser.parse(source);
            System.out.println("***********************************************");
            System.out.println(unit);
            System.out.println("***********************************************");
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

***********************************************

La description

Vous pouvez effectuer une analyse de code source Java avec la méthode parse () de JavaParser
Le résultat de l'analyse est renvoyé sous la forme CompilationUnit. --CompilationUnit hérite de la classe Node

VoidVisitor La mise en oeuvre

`MyVoidVisitor.java`


package sample.javaparser;

import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

public class MyVoidVisitor extends VoidVisitorAdapter<String> {

    @Override
    public void visit(VariableDeclarator n, String arg) {
        System.out.println("n > " + n);
        System.out.println("arg > " + arg);
        super.visit(n, arg);
    }
}

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            
            unit.accept(new MyVoidVisitor(), "ARG!!");
            
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

n > source = Paths.get("src/main/java/sample/javaparser/Main.java")
arg > ARG!!
n > unit = JavaParser.parse(source)
arg > ARG!!

La description

`MyVoidVisitor.java`


import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

public class MyVoidVisitor extends VoidVisitorAdapter<String> {

    @Override
    public void visit(VariableDeclarator n, String arg) {
        System.out.println("n > " + n);
        System.out.println("arg > " + arg);
        super.visit(n, arg);
    }

--L'interface VoidVisitor est fournie en tant queVisitor pour parcourir l'arborescence de la syntaxe. --Dans VoidVisitor, un peu moins de 100 méthodes sont déclarées rappelées pour chaque type de nœud.

La classe VoidVisitorAdapter est fournie comme une implémentation qui implémente tous ces éléments et analyse simplement les nœuds de manière récursive. --Héritez ceci et créez votre propre Visiteur
Remplacez la méthode qui reçoit le nœud que vous souhaitez traiter si nécessaire et exécutez le processus. --Enfin, en appelant super.visit (), vous pouvez continuer à rechercher le nœud enfant.

`Main.java`


            CompilationUnit unit = JavaParser.parse(source);
            
            unit.accept(new MyVoidVisitor(), "ARG!!");

--Visitor peut être utilisé en le passant à ʻaccept () de la classe CompliationUnit`.

La méthode ʻaccept () est définie dans l'interface Visitable, et la CompliationUnit` l'implémente.
Au fait, il y a aussi un moyen de passer le nœud que vous voulez scanner à la méthode visit () de VoidVisitor, mais même si vous utilisez ʻaccept (), cette méthode visit ()` est appelée après tout et ça marche. Serons les mêmes

`L'unité de complétion accepte()Implémentation de la méthode`


    @Override
    public <A> void accept(VoidVisitor<A> v, A arg) {
        v.visit(this, arg); //★ Visite du visiteur vide()Est appelé tel quel
    }

--Si vous passez une valeur au second argument de la méthode ʻaccept () (et visit () `), cette valeur continuera à fonctionner ensemble tout en traversant le nœud. -Peut-être pour lier des données et traiter des objets de destination de délégation auxquels vous souhaitez vous référer en commun?

GenericVisitor La mise en oeuvre

`MyGenericVisitor.java`


package sample.javaparser;

import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.GenericVisitorAdapter;

public class MyGenericVisitor extends GenericVisitorAdapter<Integer, String> {
    
    @Override
    public Integer visit(VariableDeclarator n, String arg) {
        System.out.println(arg);
        System.out.println(n);
        super.visit(n, arg);
        return -1;
    }
}

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            
            int result = unit.accept(new MyGenericVisitor(), "ARG!!");
            System.out.println(result);
            
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

ARG!!
source = Paths.get("src/main/java/sample/javaparser/Main.java")
-1

La description

`MyGenericVisitor.java`


import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.GenericVisitorAdapter;

public class MyGenericVisitor extends GenericVisitorAdapter<Integer, String> {
    
    @Override
    public Integer visit(VariableDeclarator n, String arg) {
        System.out.println(arg);
        System.out.println(n);
        super.visit(n, arg);
        return -1;
    }

La visite () deVoidVisitor n'a pas de valeur de retour, mais la visite () de GenericVisitor` a une valeur de retour.
Le GenericVisitorAdaptor, une classe abstraite qui implémente GenericVisitor, va ** interrompre l'analyse ** et appeler l'appelant si la méthodevisit ()renvoie une valeur autre que null pendant l'analyse. Renvoie la valeur renvoyée
Le deuxième argument de visit () est traité de la même manière que VoidVisitor.

Type de nœud

Les nœuds inclus dans l'arborescence de syntaxe abstraite héritent de la classe Node et ont la relation d'héritage suivante.

Node
┣━ArrayCreationLevel
┣━CatchClause
┣━CompilationUnit
┣━ImportDeclaration
┣━MemberValuePair
┣━ModuleDeclaration
┣━Name
┣━PackageDeclaration
┣━Parameter
┣━SimpleName
┣━VariableDeclarator
┃　
┣━BodyDeclaration
┃　┣━AnnotationMemberDeclaration
┃　┣━EnumConstantDeclaration
┃　┣━FieldDeclaration
┃　┣━InitializerDeclaration
┃　┣━CallableDeclaration
┃　┃　┣━ConstructorDeclaration
┃　┃　┗━MethodDeclaration
┃　┗━TypeDeclaration
┃　　　┣━AnnotationDeclaration
┃　　　┣━ClassOrInterfaceDeclaration
┃　　　┗━EnumDeclaration
┃　
┣━Comment
┃　┣━BlockComment
┃　┣━JavadocComment
┃　┗━LineComment
┃　
┣━Expression
┃　┣━ArrayAccessExpr
┃　┣━ArrayCreationExpr
┃　┣━ArrayInitializerExpr
┃　┣━AssignExpr
┃　┣━BinaryExpr
┃　┣━CastExpr
┃　┣━ClassExpr
┃　┣━ConditionalExpr
┃　┣━EnclosedExpr
┃　┣━FieldAccessExpr
┃　┣━InstanceOfExpr
┃　┣━LambdaExpr
┃　┣━MethodCallExpr
┃　┣━MethodReferenceExpr
┃　┣━NameExpr
┃　┣━ObjectCreationExpr
┃　┣━SuperExpr
┃　┣━ThisExpr
┃　┣━TypeExpr
┃　┣━UnaryExpr
┃　┣━VariableDeclarationExpr
┃　┣━AnnotationExpr
┃　┃　┣━MarkerAnnotationExpr
┃　┃　┣━NormalAnnotationExpr
┃　┃　┗━SingleMemberAnnotationExpr
┃　┗━LiteralExpr
┃　　　┣━BooleanLiteralExpr
┃　　　┣━NullLiteralExpr
┃　　　┗━LiteralStringValueExpr
┃　　　　　┣━CharLiteralExpr
┃　　　　　┣━DoubleLiteralExpr
┃　　　　　┣━IntegerLiteralExpr
┃　　　　　┣━LongLiteralExpr
┃　　　　　┗━StringLiteralExpr
┃　
┣━ModuleStmt
┃　┣━ModuleExportsStmt
┃　┣━ModuleOpensStmt
┃　┣━ModuleProvidesStmt
┃　┣━ModuleRequiresStmt
┃　┗━ModuleUsesStmt
┃　
┣━Statement
┃　┣━AssertStmt
┃　┣━BlockStmt
┃　┣━BreakStmt
┃　┣━ContinueStmt
┃　┣━DoStmt
┃　┣━EmptyStmt
┃　┣━ExplicitConstructorInvocationStmt
┃　┣━ExpressionStmt
┃　┣━ForeachStmt
┃　┣━ForStmt
┃　┣━IfStmt
┃　┣━LabeledStmt
┃　┣━LocalClassDeclarationStmt
┃　┣━ReturnStmt
┃　┣━SwitchEntryStmt
┃　┣━SwitchStmt
┃　┣━SynchronizedStmt
┃　┣━ThrowStmt
┃　┣━TryStmt
┃　┣━UnparsableStmt
┃　┗━WhileStmt
┃　
┗━Type
　┣━IntersectionType
　┣━PrimitiveType
　┣━UnionType
　┣━UnknownType
　┣━VoidType
　┣━WildcardType
　┗━ReferenceType
　　　┣━ArrayType
　　　┣━ClassOrInterfaceType
　　　┗━TypeParameter

L'argument de la méthode visit () peut recevoir la dernière classe de ceux-ci (il n'y a pas de méthode qui reçoit une classe au milieu de la hiérarchie telle que Type ou ReferenceType).

Vous pouvez imaginer à quel élément du code correspond le nom de la classe, mais il y a des choses que vous ne pouvez pas imaginer, alors ne prenez que cette partie et vérifiez l'opération.

ArrayCreationLevel --Spécification de la taille initiale lors de la déclaration d'un tableau --ʻInt [] array = new int [10]; [10] part of `

MemberValuePair --La partie où l'argument de l'annotation est spécifié par son nom --@ SomeAnnotation (value = "text") `` value = "text"part of`

AnnotationMemberDeclaration

@interface MyAnnotation {
    String value() default "text"; //Avec ici
    int number();                  //À propos d'ici
}

ConditionalExpr

Opérateur à trois termes

EnclosedExpr --Le groupe () utilisé dans l'expression

ExplicitConstructorInvocationStmt --this () etsuper ()qui sont explicitement appelés dans le constructeur

UnionType

La partie de la clause catch qui intercepte plusieurs types d'exceptions --} catch (OneException | OtherException e) {

UnknownType --Null objet représentant un paramètre dont la déclaration de type est omise dans l'argument de l'expression lambda --Type de ligne de .forEach (ligne-> ...)

MarkerAnnotationExpr, NormalAnnotationExpr, SingleMemberAnnotationExpr

MarkerAnnotationExpr
Un endroit où il est utilisé sans utiliser d'attributs, tels que @ Override
NormalAnnotationExpr --Un endroit où la valeur de l'attribut est définie en spécifiant le nom de l'attribut, tel que @SuppressWarnings (value =" non utilisé ")
SingleMemberAnnotationExpr --Un endroit où le nom de l'attribut est omis pour une seule valeur, telle que @SuppressWarnings (" non utilisé ")

Ceux qui ont levé les yeux mais n'ont pas compris

Name
SimpleName
UnparsableStmt
IntersectionType

Obtenez des commentaires

Les commentaires de ligne et les commentaires de bloc sont traités différemment des autres syntaxes Java normales.

`ParseCommentSample.java`


package sample.javaparser;

// a comment

// b comment
public class ParseCommentSample {
    
    // c comment
    
    private String name; // d comment
}

La classe à analyser. Essayez d'analyser cette classe pour obtenir des commentaires.

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.comments.LineComment;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ParseCommentSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            
            unit.accept(new VoidVisitorAdapter<Void>() {
                @Override
                public void visit(LineComment n, Void arg) {
                    System.out.println(n);
                    super.visit(n, arg);
                }
            }, null);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

// d comment

// b comment

«// un commentaire» et «// c comment» ont été ignorés.

Commentaires attachés au nœud et commentaires isolés

Les commentaires sont classés dans l'un des éléments suivants:

--Commentaires attachés au nœud

Commentaire isolé

Implémentez VoidVisitor comme suit et vérifiez l'opération.

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ParseCommentSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);

            System.out.println("unit orphan comment > " + unit.getOrphanComments());

            unit.accept(new VoidVisitorAdapter<Void>() {
                @Override
                public void visit(ClassOrInterfaceDeclaration n, Void arg) {
                    System.out.println("<<ClassOrInterfaceDeclaration>>");
                    System.out.println("comment > " + n.getComment());
                    System.out.println("orphan comment > " + n.getOrphanComments());
                    super.visit(n, arg);
                }

                @Override
                public void visit(FieldDeclaration n, Void arg) {
                    System.out.println("<<FieldDeclaration>>");
                    System.out.println("comment > " + n.getComment());
                    super.visit(n, arg);
                }
            }, null);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

unit orphan comment > [// a comment
]

<<ClassOrInterfaceDeclaration>>
comment > Optional[// b comment
]
orphan comment > [// c comment
]

<<FieldDeclaration>>
comment > Optional[// d comment
]

--Node a getComment () ʻet getOrphanComment () `, qui sont des méthodes pour obtenir le commentaire associé au nœud.

Si un commentaire est adjacent à un nœud, le commentaire est traité comme attaché à ce nœud.
Dans ce cas, le commentaire peut être obtenu à partir du nœud attaché avec getComment ().
En revanche, les commentaires qui ne sont liés à aucun nœud sont traités comme des ** commentaires isolés **.
Des commentaires isolés peuvent être obtenus avec getOrphanComment ()
La méthode visit () qui reçoit LineComment et BlockComment est appelée uniquement pour les commentaires attachés à un nœud. --Si vous souhaitez également gérer les commentaires orphelins, vous pouvez utiliser getOrphanComment () ou getAllContainedComments () pour obtenir tous les commentaires.

Au fait, puisqu'il n'y a qu'un seul commentaire associé à un nœud (getComment () ne renvoie qu'un seul commentaire),

// a comment
String s = "xxx"; // b comment

Si cela ressemble à, «// b comment» est traité comme un commentaire associé à la déclaration de variable, et «// a comment» devient un commentaire isolé (une telle règle).

Sortie sous forme de chaîne de caractères

`ToStringSample.java`


package sample.javaparser;

/**
 * Javadoc
 */
public class ToStringSample {
    // line comment

    /**
     * Javadoc
     * @param age age
     * @param name name
     */
    public void method(
       int age,
       String name
    ) {
        /* block comment */
        System.out.println(
            "age=" + age +
            "name=" + name
        );
    }
}

Le format est caractérisé par l'insertion intentionnelle de sauts de ligne.

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ToStringSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            System.out.println(unit);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

package sample.javaparser;

/**
 * Javadoc
 */
public class ToStringSample {

    // line comment
    /**
     * Javadoc
     * @param age age
     * @param name name
     */
    public void method(int age, String name) {
        /* block comment */
        System.out.println("age=" + age + "name=" + name);
    }
}

La description

Normalement, si vous toString () un nœud, ce sera une chaîne quelque peu formatée au lieu du formulaire d'entrée.
De plus, les commentaires sont affichés sans être effacés.

Ajuster la méthode de mise en forme

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.printer.PrettyPrinterConfiguration;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ToStringSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            PrettyPrinterConfiguration conf = new PrettyPrinterConfiguration();
            conf.setIndent("  ");
            conf.setPrintComments(false);
            conf.setPrintJavaDoc(false);
            conf.setEndOfLineCharacter("<nouvelle ligne>\n");
            
            System.out.println(unit.toString(conf));
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

package sample.javaparser;<nouvelle ligne>
<nouvelle ligne>
public class ToStringSample {<nouvelle ligne>
<nouvelle ligne>
  public void method(int age, String name) {<nouvelle ligne>
    System.out.println("age=" + age + "name=" + name);<nouvelle ligne>
  }<nouvelle ligne>
}<nouvelle ligne>

La description

En passant PrettyPrinterConfiguration à l'argument de toString (), vous pouvez spécifier la méthode de mise en forme lors du retour de l'arborescence de syntaxe dans une chaîne de caractères.

Méthode	La description	Défaut
`setIndent(String)`	Spécifiez la chaîne de caractères à utiliser pour un retrait	(4 espaces)
`setPrintComments(boolean)`	Spécifiez s'il faut afficher les commentaires	`true`
`setPrintJavaDoc(boolean)`	Spécifiez si vous souhaitez afficher Javadoc	`true`
`setEndOfLineCharacter(String)`	Spécifiez la chaîne de caractères à utiliser pour les sauts de ligne	`System.getProperty("line.separator")`

Réécrire l'arbre de syntaxe

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.stmt.BlockStmt;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);

            unit.getClassByName("Main").ifPresent(mainClass -> {
                // private final String textValue;Ajouter le champ
                mainClass.addField(String.class, "textValue", Modifier.PRIVATE, Modifier.FINAL);
                
                //Constructeur ajouté pour initialiser textValue
                ConstructorDeclaration constructor = mainClass.addConstructor(Modifier.PUBLIC);
                constructor.addParameter(String.class, "textValue"); //Ajouter un argument de constructeur
                BlockStmt body = constructor.createBody(); //Ajout du corps du constructeur
                body.addStatement("this.textValue = textValue;");
            });

            System.out.println(unit);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Résultat d'exécution **

package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.stmt.BlockStmt;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        try {
            CompilationUnit unit = JavaParser.parse(source);
            unit.getClassByName("Main").ifPresent(mainClass -> {
                // private final String textValue;Ajouter le champ
                mainClass.addField(String.class, "textValue", Modifier.PRIVATE, Modifier.FINAL);
                //Constructeur ajouté pour initialiser textValue
                ConstructorDeclaration constructor = mainClass.addConstructor(Modifier.PUBLIC);
                //Ajouter un argument de constructeur
                constructor.addParameter(String.class, "textValue");
                //Ajout du corps du constructeur
                BlockStmt body = constructor.createBody();
                body.addStatement("this.textValue = textValue;");
            });
            System.out.println(unit);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }

    private final String textValue;

    public Main(String textValue) {
        this.textValue = textValue;
    }
}

--Node fournit une méthode pour réécrire l'arbre de syntaxe dans n'importe quelle forme.

L'API est facile à comprendre si vous regardez l'achèvement de la méthode de l'EDI. --Il existe également une méthode de suppression telle que remove ()

référence

Home · javaparser/javaparser Wiki

[^ 1]: Analyse du code source Java JDT --Qiita

Notes d'utilisation de JavaParser

Qu'est-ce que JavaParser?

build.gradle

Main.java

MyVoidVisitor.java

Main.java

MyVoidVisitor.java

Main.java

L'unité de complétion accepte()Implémentation de la méthode

MyGenericVisitor.java

Main.java

MyGenericVisitor.java

Type de nœud

Ceux qui ont levé les yeux mais n'ont pas compris

Obtenez des commentaires

ParseCommentSample.java

Main.java

Commentaires attachés au nœud et commentaires isolés

Main.java

Sortie sous forme de chaîne de caractères

ToStringSample.java

Main.java

Ajuster la méthode de mise en forme

Main.java

Réécrire l'arbre de syntaxe

Main.java

référence

`build.gradle`

`Main.java`

`MyVoidVisitor.java`

`Main.java`

`MyVoidVisitor.java`

`Main.java`

`L'unité de complétion accepte()Implémentation de la méthode`

`MyGenericVisitor.java`

`Main.java`

`MyGenericVisitor.java`

`ParseCommentSample.java`

`Main.java`

`Main.java`

`ToStringSample.java`

`Main.java`

`Main.java`

`Main.java`