Merge branch 'topic/gpr-tool-completion' into 'master'

Provide completion help for tool switches in GPR files

See merge request eng/ide/ada_language_server!2158

Author: AnthonyLeonardoGracio

gnat/lsp_server.gpr

@@ -48,6 +48,7 @@ project LSP_Server is
       "../source/common",
       "../source/gpr",
       "../source/ada/generated",
+      "../source/gpr/generated",
       "../source/memory");
 
    for Object_Dir use "../.obj/server";

scripts/generate_tool_help_db.py

@@ -0,0 +1,374 @@
+#!/usr/bin/env python3
+"""
+NOTE: this script has been developed with AI assistance.
+
+Generate an Ada package with embedded tool switches database.
+
+This script runs various tools with their help options and extracts the switches
+and their associated documentation into a structured JSON database, which is then
+embedded into an Ada package specification as string constants.
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from typing import Dict, List, Optional
+
+
+class HelpParser:
+    """Base class for parsing tool help output."""
+
+    def parse(self, help_text: str) -> Dict[str, str]:
+        """Parse help text and return a dictionary of switches to documentation.
+
+        Args:
+            help_text: The raw help output from the tool
+
+        Returns:
+            Dictionary mapping switch names to their documentation
+        """
+        raise NotImplementedError("Subclasses must implement parse()")
+
+
+class GnatHelpParser(HelpParser):
+    """Parser for GNAT compiler help output."""
+
+    def parse(self, help_text: str) -> Dict[str, str]:
+        """Parse GNAT help output format.
+
+        GNAT help has lines like:
+          -switch   Documentation text that may span
+                    multiple lines
+        or:
+         -switch   Documentation text
+             --long-switch  More documentation
+        """
+        switches = {}
+        current_switch = None
+        current_doc = []
+
+        lines = help_text.split("\n")
+
+        for line in lines:
+            # Check if this line starts a new switch (starts with 1-5 spaces and a dash)
+            # Handles both "  -switch" and " -switch" and "     --switch" patterns
+            match = re.match(r"^ {1,5}(-+\S+(?:,\s*-+\S+)*)\s+(.*)$", line)
+            if match:
+                # Save previous switch if any
+                if current_switch:
+                    switches[current_switch] = " ".join(current_doc).strip()
+
+                # Start new switch
+                current_switch = match.group(1)
+                current_doc = [match.group(2)] if match.group(2).strip() else []
+            elif current_switch:
+                # Continuation line - check if it's indented documentation
+                stripped = line.strip()
+                if stripped and not line.startswith(
+                    "   ."
+                ):  # Skip mode value descriptions
+                    # Only add if it doesn't look like a new section header
+                    if not re.match(r"^[A-Z][a-z].*:$", stripped):
+                        current_doc.append(stripped)
+                elif stripped == "":
+                    # Empty line might indicate end of this switch's documentation
+                    pass
+
+        # Don't forget the last switch
+        if current_switch:
+            switches[current_switch] = " ".join(current_doc).strip()
+
+        return switches
+
+
+class GenericHelpParser(HelpParser):
+    """Generic parser for standard help output formats."""
+
+    def parse(self, help_text: str) -> Dict[str, str]:
+        """Parse generic help output.
+
+        Tries to identify lines that look like:
+          -switch, --long-switch    Documentation
+        or:
+          -switch    Documentation
+        """
+        switches = {}
+        current_switch = None
+        current_doc = []
+
+        lines = help_text.split("\n")
+
+        for line in lines:
+            # Try to match common switch patterns
+            match = re.match(r"^\s{0,4}(-+\S+(?:,\s*-+\S+)*)\s{2,}(.*)$", line)
+            if match:
+                # Save previous switch if any
+                if current_switch:
+                    switches[current_switch] = " ".join(current_doc).strip()
+
+                # Start new switch (may be multiple comma-separated)
+                switch_list = match.group(1)
+                current_switch = switch_list
+                current_doc = [match.group(2)]
+            elif current_switch and line.startswith(" " * 6) and line.strip():
+                # Continuation line with significant indentation
+                current_doc.append(line.strip())
+            elif line.strip() == "":
+                # Empty line might end current switch
+                if current_switch and current_doc:
+                    switches[current_switch] = " ".join(current_doc).strip()
+                    current_switch = None
+                    current_doc = []
+
+        # Don't forget the last switch
+        if current_switch and current_doc:
+            switches[current_switch] = " ".join(current_doc).strip()
+
+        return switches
+
+
+def run_tool_help(tool_command: str) -> Optional[str]:
+    """Run a tool with its help option and capture output.
+
+    Args:
+        tool_command: The full command to run (e.g., "gnat --help-ada")
+
+    Returns:
+        The help output as a string, or None if the command failed
+    """
+    try:
+        result = subprocess.run(
+            tool_command.split(), capture_output=True, text=True, timeout=30
+        )
+        # Many tools output help to stderr, so combine both
+        output = result.stdout + result.stderr
+        return output if output.strip() else None
+    except (
+        subprocess.TimeoutExpired,
+        subprocess.CalledProcessError,
+        FileNotFoundError,
+    ) as e:
+        print(f"Error running '{tool_command}': {e}", file=sys.stderr)
+        return None
+
+
+def select_parser(tool_name: str) -> HelpParser:
+    """Select the appropriate parser for a given tool.
+
+    Args:
+        tool_name: Name of the tool (extracted from command)
+
+    Returns:
+        An appropriate HelpParser instance
+    """
+    tool_name_lower = tool_name.lower()
+    if tool_name_lower in ("gnat", "gnatprove"):
+        return GnatHelpParser()
+    else:
+        return GenericHelpParser()
+
+
+def extract_tool_name(tool_command: str) -> str:
+    """Extract the tool name from a command string.
+
+    Args:
+        tool_command: Full command like "gnat --help-ada"
+
+    Returns:
+        Just the tool name, e.g., "gnat"
+    """
+    return tool_command.split()[0]
+
+
+def escape_ada_string(s: str) -> str:
+    """Escape a string for use in an Ada string literal.
+
+    Args:
+        s: The string to escape
+
+    Returns:
+        The escaped string suitable for Ada string literals
+    """
+    # In Ada, quotes are doubled to escape them
+    return s.replace('"', '""')
+
+
+def split_string_for_ada(json_str: str, max_length: int = 1000) -> List[str]:
+    """Split a JSON string into chunks suitable for Ada string constants.
+
+    Args:
+        json_str: The JSON string to split
+        max_length: Maximum length of each chunk (to avoid Ada line length limits)
+
+    Returns:
+        List of string chunks
+    """
+    chunks = []
+    i = 0
+    while i < len(json_str):
+        # Try to find a good breaking point (after comma or closing brace)
+        end = min(i + max_length, len(json_str))
+        if end < len(json_str):
+            # Look back for a good break point
+            for j in range(end, max(i, end - 100), -1):
+                if json_str[j] in ",}]":
+                    end = j + 1
+                    break
+
+        chunks.append(json_str[i:end])
+        i = end
+
+    return chunks
+
+
+def generate_ada_package(database: dict, output_dir: str):
+    """Generate an Ada package spec with the JSON database embedded.
+
+    Args:
+        database: The tool database dictionary
+        output_dir: Directory where to write the Ada package spec
+    """
+    import os
+
+    # Convert database to compact JSON string
+    json_str = json.dumps(database, ensure_ascii=False, separators=(",", ":"))
+
+    # Escape for Ada
+    escaped_json = escape_ada_string(json_str)
+
+    # Split into manageable chunks
+    chunks = split_string_for_ada(escaped_json, max_length=2000)
+
+    # Generate Ada package spec
+    ada_code = []
+    ada_code.append("--  Automatically generated, do not edit.")
+    ada_code.append("")
+    ada_code.append("pragma Style_Checks (Off);")
+    ada_code.append("")
+    ada_code.append("package LSP.GPR_Completions.Tools.Database is")
+    ada_code.append("")
+
+    # Generate string constants for each chunk
+    for i, chunk in enumerate(chunks, 1):
+        ada_code.append(f'   Db{i} : constant String := "{chunk}";')
+        ada_code.append("")
+
+    # Generate the main concatenated constant
+    db_parts = " & ".join(f"Db{i}" for i in range(1, len(chunks) + 1))
+    ada_code.append(f"   Db : constant String := {db_parts};")
+    ada_code.append("")
+    ada_code.append("end LSP.GPR_Completions.Tools.Database;")
+
+    # Write to file
+    output_file = os.path.join(output_dir, "lsp-gpr_completions-tools-database.ads")
+    with open(output_file, "w", encoding="utf-8") as f:
+        f.write("\n".join(ada_code))
+
+    print(f"\nAda package written to: {output_file}")
+    print(f"Total string chunks: {len(chunks)}")
+    print(f"Total JSON size: {len(json_str)} characters")
+
+
+def generate_database(tool_configs: List[str], output_dir: str, pretty: bool = True):
+    """Generate the Ada package database from tool help outputs.
+
+    Args:
+        tool_configs: List of tool commands (e.g., ["gnat --help-ada"])
+        output_dir: Directory where to write the Ada package
+        pretty: Unused (kept for compatibility)
+    """
+    database = {}
+
+    for tool_command in tool_configs:
+        print(f"Processing: {tool_command}")
+
+        # Extract tool name for the database key
+        tool_name = extract_tool_name(tool_command)
+
+        # Run the tool and get help output
+        help_text = run_tool_help(tool_command)
+        if not help_text:
+            print(
+                f"  Warning: No help output received for '{tool_command}'",
+                file=sys.stderr,
+            )
+            continue
+
+        # Select appropriate parser
+        parser = select_parser(tool_name)
+
+        # Parse the help text
+        switches = parser.parse(help_text)
+
+        if not switches:
+            print(
+                f"  Warning: No switches parsed from '{tool_command}'", file=sys.stderr
+            )
+            continue
+
+        print(f"  Found {len(switches)} switches")
+
+        # Store in database (use tool name as key)
+        database[tool_name] = {
+            "command": tool_command,
+            "switches": switches,
+        }
+
+    # Generate Ada package
+    generate_ada_package(database, output_dir)
+
+    print(f"Total tools processed: {len(database)}")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Generate Ada package with embedded tool switches database",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s -o source/gpr/generated "gnat --help-ada"
+  %(prog)s -o source/gpr/generated "gnat --help-ada" "gnatprove --help"
+  %(prog)s --default -o source/gpr/generated
+        """,
+    )
+
+    parser.add_argument(
+        "tools", nargs="*", help='Tool commands to process (e.g., "gnat --help-ada")'
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="source/gpr/generated",
+        help="Output directory for Ada package (default: source/gpr/generated)",
+    )
+
+    parser.add_argument(
+        "--compact",
+        action="store_true",
+        help="Unused (kept for compatibility)",
+    )
+
+    parser.add_argument(
+        "--default",
+        action="store_true",
+        help="Process default GNAT tools (gnat --help-ada, gnatprove --help)",
+    )
+
+    args = parser.parse_args()
+
+    # Use default tools if --default is specified or no tools provided
+    if args.default or not args.tools:
+        default_tools = ["gnat --help-ada", "gnatprove --help"]
+        tools_to_process = default_tools
+    else:
+        tools_to_process = args.tools
+
+    generate_database(tools_to_process, args.output, pretty=not args.compact)
+
+
+if __name__ == "__main__":
+    main()