Improvements: review antlr grammar and parsing

[cmoulliard]

Improvements

Parsing

On the generic of find all, what I see is that each new entity requires dedicated code: an if/case in parse(), a buildFindAllXxxRecipe(), and potentially an extractXxxResults() for each DataTable type. This means find all java.annotation, find all java.method, etc. will each need their own code block.
This remark is also true for every existing scanner as it is needed to :
translate the antlr query to its scanner request -> execute -> collect results -> generate/extractResults -> mtool report

Antlr grammar

The new clause with FIND? 'all'? is backwards compatible, good. But there is one concern as assignmentOp includes all as an operator at the same level as 'is' and '='. I don't understand the semantic meaning of all as an assignment operator, what would java.annotation all '@SpringBootApplication' mean ? I think all only makes sense as a quantifier in find all, not as an operator.

The ANTLR grammar accepts any find all . combination, but the scanner only handles java.class, so the parser will accept queries that the backend doesn't know how to execute yet, we need a backend mechanism able to scale.

Originally posted by @aureamunoz in #337 (review)

[cmoulliard]

Instead of using a new operation all which is defined at the level as is, =, I suggest that we review the syntax as such

find <WHAT> in <WHERE>

The <WHAT> defines the filter or target criteria.

• * or all: Matches all entities within the given scope.
• key=value (or name=value, gav=value): Filters by specific attributes.

<WHERE>: Specifies the target files, symbols, or contexts (and supports logical chaining via AND/OR).

Examples

-- Find everything

find * in java.class
find * in file.properties

-- Target attribute filtering (Note: only values are quoted)

find name='org.springframework.boot.xxx' in java.annotation
find key='quarkus.resteasy.*' in properties.key
find gav='org.springframework.boot:spring-boot-starter-web' in pom.dependencies

-- Passing collections/arrays

find gavs='org.springframework.boot:spring-boot-starter-web,org.springframework.boot:spring-boot-starter-data-jpa' in pom.dependencies

-- Multi-context scopes

find name='org.springframework.boot.xxx' in java.annotation AND java.class
find name='org.springframework.boot.xxx' in java.annotation OR java.class

Remarks:

• Fixing the all constraint: By extracting * or all into the block, we bypass our current parser limitation where all was awkwardly trapped in the comparison operator list (is, =, etc.). Under the hood, the engine can translate * into an implicit name=all or key=all execution.
• Flexible Matching Modes: The value side of the key=value pair should dynamically adapt its matching strategy based on the input text. For example:
  • Standard strings imply an exact match (is / =).
  • Inclusion of a * implies a contains or startsWith glob evaluation.
  • Full regular expressions can be supported for advanced patterns.

@aureamunoz

[cmoulliard]

Something else that we could also develop to externalize for a fileType.(entity)? are the:

• allowed mode or queries
• supported attributes,
• query/scanner: s-expression, recipe, etc
• class to be used to convert a scanner's response with the Match.

Example

scopes:
  - fileType: "java"
    symbol: "annotation"
    allowedModes: ["*", "attribute-filter"]
    supportedAttributes: ["name", "key"]
    scanners:
      treesitter:
        query: |
          (modifiers
            (annotation
              name: (identifier) @annot_name
              arguments: (annotation_argument_list)? @annot_args))
      openrewrite:
        recipe: "org.openrewrite.java.search.FindAnnotations"

  - fileType: "java"
    symbol: "class"
    allowedModes: ["*"]
    scanners:
      treesitter:
        query: |
          (class_declaration 
            name: (identifier) @class_name)

  - fileType: "pom"
    symbol: "dependencies"
    allowedModes: ["*", "attribute-filter"]
    supportedAttributes: ["gav", "gavs", "groupId", "artifactId", "version"]
    scanners:
      maven-model:
        strategy: "builtin-model-parser"
      openrewrite:
        recipe: "org.openrewrite.maven.search.FindDependency"

  - fileType: "properties"
    symbol: "key"
    allowedModes: ["*", "attribute-filter"]
    supportedAttributes: ["key", "name"]
    scanners:
      treesitter:
        query: |
          (pair 
            key: (property_key) @prop_key)