Add CLI tool for parsing SCIP symbols to JSON

Summary:
Add a new command-line tool `scip-symbol-parse` to parse SCIP symbol strings and output structured JSON. This enables easier debugging and inspection of SCIP symbols by providing a simple interface to the existing `scip_symbol` parsing library.

The tool supports:
- Parsing symbols from command-line arguments or stdin
- Optional pretty-printing for human-readable output
- Batch processing via stdin mode

The existing `scip_symbol` library was enhanced with serde serialization support to enable JSON output, and the `Method` descriptor variant was converted from tuple-style to named fields for clearer serialization.

Differential Revision: D87650280

fbshipit-source-id: 5b0b91b31ef5f3861cc1a4ffa42bcaf83b33b2ec

Author: Catherine Gasnier

glean/lang/scip/indexer/scip_to_glean/cli/src/lsif.rs

@@ -49,7 +49,7 @@ impl SymbolKind {
             Namespace => SkPackage,
             Type => SkClass,
             Term => SkVariable,
-            Method(_) => SkMethod,
+            Method { .. } => SkMethod,
             TypeParameter => SkTypeParameter,
             Parameter => SkField,
             Meta => SkUnknown,

glean/lang/scip/indexer/scip_to_glean/scip_symbol/src/lib.rs

@@ -17,6 +17,10 @@
 //! - Parses all descriptor types (namespace, type, term, method, parameter, etc.)
 //! - Supports the "." placeholder for empty package fields
 
+use serde::Serialize;
+
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
 #[allow(dead_code)]
 pub enum ScipSymbol {
     Local {
@@ -29,29 +33,31 @@ pub enum ScipSymbol {
     },
 }
 
+#[derive(Debug, Clone, PartialEq, Serialize)]
 #[allow(dead_code)]
 pub struct Package {
     pub manager: Option<String>,
     pub name: Option<String>,
     pub version: Option<String>,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize)]
 pub struct Descriptor {
     pub name: String,
     pub kind: DescriptorKind,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(tag = "kind", rename_all = "lowercase")]
 pub enum DescriptorKind {
-    Namespace,              // name/
-    Type,                   // name#
-    Term,                   // name.
-    Method(Option<String>), // name(<disambiguator>?).
-    TypeParameter,          // [name]
-    Parameter,              // (name)
-    Meta,                   // name:
-    Macro,                  // name!
+    Namespace,
+    Type,
+    Term,
+    Method { disambiguator: Option<String> },
+    TypeParameter,
+    Parameter,
+    Meta,
+    Macro,
 }
 
 /// Parses a SCIP symbol string according to the SCIP specification.
@@ -296,7 +302,7 @@ fn parse_method(descriptors_str: &str, name: String, start_pos: usize) -> (Descr
     (
         Descriptor {
             name,
-            kind: DescriptorKind::Method(disambiguator),
+            kind: DescriptorKind::Method { disambiguator },
         },
         i,
     )
@@ -468,7 +474,12 @@ mod tests {
         assert_eq!(descriptors[0].name, "MyClass");
         assert_eq!(descriptors[0].kind, DescriptorKind::Type);
         assert_eq!(descriptors[1].name, "myMethod");
-        assert_eq!(descriptors[1].kind, DescriptorKind::Method(None));
+        assert_eq!(
+            descriptors[1].kind,
+            DescriptorKind::Method {
+                disambiguator: None
+            }
+        );
     }
 
     #[test]
@@ -496,7 +507,12 @@ mod tests {
 
         assert_eq!(descriptors.len(), 2);
         assert_eq!(descriptors[0].name, "func");
-        assert_eq!(descriptors[0].kind, DescriptorKind::Method(None));
+        assert_eq!(
+            descriptors[0].kind,
+            DescriptorKind::Method {
+                disambiguator: None
+            }
+        );
         assert_eq!(descriptors[1].name, "param");
         assert_eq!(descriptors[1].kind, DescriptorKind::Parameter);
     }
@@ -597,7 +613,12 @@ mod tests {
         assert_eq!(descriptors[0].name, "MyClass");
         assert_eq!(descriptors[0].kind, DescriptorKind::Type);
         assert_eq!(descriptors[1].name, "special method");
-        assert_eq!(descriptors[1].kind, DescriptorKind::Method(None));
+        assert_eq!(
+            descriptors[1].kind,
+            DescriptorKind::Method {
+                disambiguator: None
+            }
+        );
     }
 
     #[test]
@@ -615,7 +636,9 @@ mod tests {
         assert_eq!(descriptors[1].name, "myMethod");
         assert_eq!(
             descriptors[1].kind,
-            DescriptorKind::Method(Some("disambig".to_string()))
+            DescriptorKind::Method {
+                disambiguator: Some("disambig".to_string())
+            }
         );
     }
 

glean/lang/scip/indexer/scip_to_glean/scip_symbol_parse/README.md

@@ -0,0 +1,112 @@
+# scip-symbol-parse
+
+A CLI tool for parsing SCIP symbols and outputting them as JSON.
+
+## Overview
+
+This tool parses SCIP (SCIP Code Intelligence Protocol) symbols according to the specification and outputs the parsed structure as JSON. It uses the `scip_symbol` library for parsing logic.
+
+## Usage
+
+### Parse a single symbol
+
+```bash
+scip-symbol-parse "rust-analyzer cargo std v1.0 io/IsTerminal#"
+```
+
+### Parse from stdin
+
+```bash
+echo "local myVar" | scip-symbol-parse --stdin
+```
+
+### Pretty-print JSON output
+
+```bash
+scip-symbol-parse --pretty "rust-analyzer cargo std v1.0 io/IsTerminal#"
+```
+
+### Process multiple symbols from a file
+
+```bash
+cat symbols.txt | scip-symbol-parse --stdin
+```
+
+## Options
+
+- `<SYMBOL>` - The SCIP symbol to parse (positional argument)
+- `--stdin, -s` - Read symbols from stdin (one per line)
+- `--pretty, -p` - Pretty-print JSON output
+
+## Examples
+
+### Global symbol
+
+```bash
+$ scip-symbol-parse "rust-analyzer cargo std v1.0 io/IsTerminal#"
+{"type":"global","scheme":"rust-analyzer","package":{"manager":"cargo","name":"std","version":"v1.0"},"descriptors":[{"name":"io","kind":"namespace"},{"name":"IsTerminal","kind":"type"}]}
+```
+
+### Local symbol
+
+```bash
+$ scip-symbol-parse "local myVar"
+{"type":"local","id":"myVar"}
+```
+
+### Pretty-printed output
+
+```bash
+$ scip-symbol-parse --pretty "scip . . . MyClass#myMethod()."
+{
+  "type": "global",
+  "scheme": "scip",
+  "package": {
+    "manager": null,
+    "name": null,
+    "version": null
+  },
+  "descriptors": [
+    {
+      "name": "MyClass",
+      "kind": "type"
+    },
+    {
+      "name": "myMethod",
+      "kind": {
+        "kind": "method",
+        "disambiguator": null
+      }
+    }
+  ]
+}
+```
+
+## Building
+
+```bash
+buck2 build //fbcode/glean/lang/scip/indexer/scip_to_glean/scip_symbol_parse:scip-symbol-parse
+```
+
+## Testing
+
+Run the test suite directly:
+
+```bash
+./test.sh
+```
+
+Or run via Buck:
+
+```bash
+buck2 test //fbcode/glean/lang/scip/indexer/scip_to_glean/scip_symbol_parse:test
+```
+
+Each test validates the complete JSON output to ensure correctness.
+
+Requirements:
+- `buck2` (for building)
+
+## SCIP Symbol Format
+
+This is documented in scip.proto: https://github.com/sourcegraph/scip/blob/main/scip.proto#L147-L188

glean/lang/scip/indexer/scip_to_glean/scip_symbol_parse/src/main.rs

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+//! CLI tool for parsing SCIP symbols and outputting them as JSON.
+//!
+//! This tool takes SCIP symbol strings as input and parses them using the
+//! scip_symbol library, then outputs the parsed structure as JSON.
+//!
+//! Usage:
+//!   scip-symbol-parse <symbol>
+//!   scip-symbol-parse --stdin
+//!
+//! Examples:
+//!   scip-symbol-parse "rust-analyzer cargo std v1.0 io/IsTerminal#"
+//!   echo "local myVar" | scip-symbol-parse --stdin
+
+use std::io::BufRead;
+use std::io::{self};
+
+use anyhow::Result;
+use clap::Parser;
+use scip_symbol::parse_scip_symbol;
+
+#[derive(Parser, Debug)]
+#[clap(name = "scip-symbol-parse")]
+#[clap(about = "Parse SCIP symbols and output as JSON", long_about = None)]
+struct Args {
+    /// SCIP symbol to parse
+    #[clap(value_name = "SYMBOL")]
+    symbol: Option<String>,
+
+    /// Read symbols from stdin (one per line)
+    #[clap(short, long)]
+    stdin: bool,
+
+    /// Pretty-print JSON output
+    #[clap(short, long)]
+    pretty: bool,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    if args.stdin {
+        // Read from stdin, one symbol per line
+        let stdin = io::stdin();
+        for line in stdin.lock().lines() {
+            let line = line?;
+            let line = line.trim();
+            if line.is_empty() {
+                continue;
+            }
+            parse_and_output(line, args.pretty)?;
+        }
+    } else if let Some(symbol) = &args.symbol {
+        // Parse single symbol from command line argument
+        parse_and_output(symbol, args.pretty)?;
+    } else {
+        eprintln!("Error: Either provide a symbol as an argument or use --stdin");
+        std::process::exit(1);
+    }
+
+    Ok(())
+}
+
+fn parse_and_output(symbol: &str, pretty: bool) -> Result<()> {
+    let parsed = parse_scip_symbol(symbol);
+
+    let json = if pretty {
+        serde_json::to_string_pretty(&parsed)?
+    } else {
+        serde_json::to_string(&parsed)?
+    };
+
+    println!("{}", json);
+    Ok(())
+}