Merge branch 'topic/selector_refactor' into 'master'

Implement selector translation

See merge request eng/libadalang/langkit-query-language!582

Author: Killian Perlin

lkql_jit/cli/src/main/java/com/adacore/lkql_jit/cli/LKQLRefactor.java

@@ -9,29 +9,40 @@
 
 import com.adacore.lkql_jit.options.Refactorings.LKQLToLkt;
 import com.adacore.lkql_jit.options.Refactorings.Refactoring;
+import com.adacore.lkql_jit.options.Refactorings.TokenBasedRefactoring;
+import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Callable;
 import picocli.CommandLine;
 
 /**
- * Refactor command for LKQL. Allows to run automatic migrations, allowing the LKQL team to create
- * migrators to adapt to syntactic or semantic changes in LKQL.
+ * Refactor command for LKQL. Allows to run automatic migrations, allowing the
+ * LKQL team to create migrators to adapt to syntactic or semantic changes in
+ * LKQL.
  *
- * <p>Migrators work on the stream of tokens directly. Migrator implementer will attach actions
- * (append/prepend/replace) on tokens, which allows to modify the output stream without working on
- * text directly, which simplifies the expression of refactorings.
+ * <p>
+ * Migrators are just an implementation of the functionnal interface
+ * 'Refactoring'. It expects an LKQL unit as input and produces the new unit
+ * content as a 'String'.
  *
- * <p>A migrator implementer will typically:
+ * <p>
+ * In practice, a 'Refactoring' implementation will be of one of 2 kinds:
+ * 1. A 'TokenBasedRefactoring' working on the stream of tokens directly and
+ * producing rewriting actions on each token of the stream.
+ * 2. A 'TreeBasedRefactoring' working on the Liblkqllang syntax tree and
+ * producing a new 'String' directly.
  *
- * <p>1. Find the nodes he wants to refactor in the LKQL tree 2. From those nodes, find the tokens
- * inside the nodes that need to be altered 3. Attach actions to those tokens
+ * <p>
+ * Then the rewriter will emit a new file for every LKQL unit, either inplace or
+ * on stdout.
  *
- * <p>Then the rewriter will emit a new file for every LKQL unit, either inplace or on stdout.
+ * <p>
+ * To add a refactoring, you need to extend the 'RefactoringKind' enum to add a
+ * new refactoring id, and then extend the 'getRefactoring' method to return the
+ * corresponding implementation of 'Refactoring' to apply.
  *
- * <p>To add a refactoring, you need to extend the 'refactoringKind' enum to add a new refactoring
- * id, and then extend the 'getRefactoring' method to return an anonymous function that will add
- * actions to the list of actions.
  */
 @CommandLine.Command(
     name = "refactor",
@@ -66,40 +77,49 @@ private enum RefactoringKind {
      */
     public Refactoring getRefactoring(AnalysisUnit unit) {
         return switch (refactoring) {
-            case IS_TO_COLON -> (Refactoring.State state) -> {
-                for (var det : Refactoring.findAll(unit.getRoot(), n ->
-                    n instanceof NodePatternDetail
-                )) {
-                    var tokIs = Refactoring.firstWithPred(
-                        det.tokenStart(),
-                        t -> t.kind == TokenKind.LKQL_IS
-                    );
+            case IS_TO_COLON -> (TokenBasedRefactoring) state -> {
+                Refactoring.stream(state.unit.getRoot())
+                    .filter(n -> n instanceof NodePatternDetail)
+                    .forEach(det -> {
+                        Refactoring.streamFrom(det.tokenStart())
+                            .filter(t -> t.kind == TokenKind.LKQL_IS)
+                            .findFirst()
+                            .ifPresent(tokIs -> {
+                                // Replace "is" -> ":"
+                                state.replace(tokIs, ":");
 
-                    if (!tokIs.isNone()) {
-                        // Replace "is" -> ":"
-                        state.replace(tokIs, ":");
-
-                        // Get rid of previous token if it is a whitespace
-                        var prev = tokIs.previous();
-                        if (Refactoring.isWhitespace(prev)) {
-                            state.delete(tokIs.previous());
-                        }
-                    }
-                }
+                                // Get rid of previous token if it is a whitespace
+                                var prev = tokIs.previous();
+                                if (Refactoring.isWhitespace(prev)) {
+                                    state.delete(prev);
+                                }
+                            });
+                    });
             };
-            case TO_LKQL_V2 -> LKQLToLkt.instantiate();
+            case TO_LKQL_V2 -> new LKQLToLkt();
         };
     }
 
+    /**
+     * Rewrite a unit by printing refactored file, either to stdout, or to the
+     * original file, depending on the value of the '-i' command line flag.
+     */
     @Override
     public Integer call() {
         var ctx = AnalysisContext.create();
         for (var file : files) {
             var unit = ctx.getUnitFromFile(file);
-            var refactoring = getRefactoring(unit);
-            var state = new Refactoring.State(unit);
-            refactoring.applyRefactor(state);
-            state.printAllTokens(this.inPlace);
+            var result = getRefactoring(unit).apply(unit);
+
+            if (inPlace) {
+                try (var writer = new PrintWriter(unit.getFileName(), StandardCharsets.UTF_8)) {
+                    writer.print(result);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            } else {
+                System.out.print(result);
+            }
         }
         return 0;
     }