hecks 2.9.0 → 3.0.0

data/rust/lsp/src/json.rs

@@ -0,0 +1,385 @@
+//! A minimal, dependency-free JSON value for reading and writing JSON-RPC messages.
+//! `write` is compact and `Number` is `i64`, since only ids and positions pass through.
+
+use std::fmt::Write as _;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Json {
+    Null,
+    Bool(bool),
+    Number(i64),
+    String(String),
+    Array(Vec<Json>),
+    /// Insertion-ordered pairs.
+    Object(Vec<(String, Json)>),
+}
+
+impl Json {
+    pub fn parse(text: &str) -> Result<Json, String> {
+        let mut p = Parser { bytes: text.as_bytes(), pos: 0 };
+        p.skip_ws();
+        let value = p.parse_value()?;
+        p.skip_ws();
+        if p.pos != p.bytes.len() {
+            return Err(format!("trailing content at byte {}", p.pos));
+        }
+        Ok(value)
+    }
+
+    pub fn get(&self, key: &str) -> Option<&Json> {
+        match self {
+            Json::Object(pairs) => pairs
+                .iter()
+                .find(|(k, v)| k == key && !matches!(v, Json::Null))
+                .map(|(_, v)| v),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            Json::String(s) => Some(s.as_str()),
+            _ => None,
+        }
+    }
+
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            Json::Number(n) => Some(*n),
+            _ => None,
+        }
+    }
+
+    pub fn as_array(&self) -> Option<&[Json]> {
+        match self {
+            Json::Array(items) => Some(items.as_slice()),
+            _ => None,
+        }
+    }
+
+    pub fn string(s: impl Into<String>) -> Json {
+        Json::String(s.into())
+    }
+
+    pub fn object(pairs: Vec<(&str, Json)>) -> Json {
+        Json::Object(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+    }
+}
+
+struct Parser<'a> {
+    bytes: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> Parser<'a> {
+    fn peek(&self) -> Option<u8> {
+        self.bytes.get(self.pos).copied()
+    }
+
+    fn skip_ws(&mut self) {
+        while let Some(b) = self.peek() {
+            if b == b' ' || b == b'\t' || b == b'\n' || b == b'\r' {
+                self.pos += 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn expect(&mut self, b: u8) -> Result<(), String> {
+        if self.peek() == Some(b) {
+            self.pos += 1;
+            Ok(())
+        } else {
+            Err(format!(
+                "expected {:?} at byte {}, found {:?}",
+                b as char,
+                self.pos,
+                self.peek().map(|c| c as char)
+            ))
+        }
+    }
+
+    fn parse_value(&mut self) -> Result<Json, String> {
+        self.skip_ws();
+        match self.peek() {
+            Some(b'{') => self.parse_object(),
+            Some(b'[') => self.parse_array(),
+            Some(b'"') => Ok(Json::String(self.parse_string()?)),
+            Some(b't') => {
+                self.expect_literal("true")?;
+                Ok(Json::Bool(true))
+            }
+            Some(b'f') => {
+                self.expect_literal("false")?;
+                Ok(Json::Bool(false))
+            }
+            Some(b'n') => {
+                self.expect_literal("null")?;
+                Ok(Json::Null)
+            }
+            Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
+            other => Err(format!(
+                "unexpected byte {:?} at {}",
+                other.map(|c| c as char),
+                self.pos
+            )),
+        }
+    }
+
+    fn expect_literal(&mut self, lit: &str) -> Result<(), String> {
+        let end = self.pos + lit.len();
+        if end <= self.bytes.len() && &self.bytes[self.pos..end] == lit.as_bytes() {
+            self.pos = end;
+            Ok(())
+        } else {
+            Err(format!("expected literal {lit:?} at byte {}", self.pos))
+        }
+    }
+
+    fn parse_object(&mut self) -> Result<Json, String> {
+        self.expect(b'{')?;
+        let mut pairs = Vec::new();
+        self.skip_ws();
+        if self.peek() == Some(b'}') {
+            self.pos += 1;
+            return Ok(Json::Object(pairs));
+        }
+        loop {
+            self.skip_ws();
+            let key = self.parse_string()?;
+            self.skip_ws();
+            self.expect(b':')?;
+            let value = self.parse_value()?;
+            pairs.push((key, value));
+            self.skip_ws();
+            match self.peek() {
+                Some(b',') => self.pos += 1,
+                Some(b'}') => {
+                    self.pos += 1;
+                    break;
+                }
+                other => {
+                    return Err(format!(
+                        "expected ',' or '}}' at byte {}, found {:?}",
+                        self.pos,
+                        other.map(|c| c as char)
+                    ))
+                }
+            }
+        }
+        Ok(Json::Object(pairs))
+    }
+
+    fn parse_array(&mut self) -> Result<Json, String> {
+        self.expect(b'[')?;
+        let mut items = Vec::new();
+        self.skip_ws();
+        if self.peek() == Some(b']') {
+            self.pos += 1;
+            return Ok(Json::Array(items));
+        }
+        loop {
+            let value = self.parse_value()?;
+            items.push(value);
+            self.skip_ws();
+            match self.peek() {
+                Some(b',') => self.pos += 1,
+                Some(b']') => {
+                    self.pos += 1;
+                    break;
+                }
+                other => {
+                    return Err(format!(
+                        "expected ',' or ']' at byte {}, found {:?}",
+                        self.pos,
+                        other.map(|c| c as char)
+                    ))
+                }
+            }
+        }
+        Ok(Json::Array(items))
+    }
+
+    fn parse_string(&mut self) -> Result<String, String> {
+        self.expect(b'"')?;
+        let mut out = String::new();
+        loop {
+            match self.peek() {
+                None => return Err("unterminated string".to_string()),
+                Some(b'"') => {
+                    self.pos += 1;
+                    break;
+                }
+                Some(b'\\') => {
+                    self.pos += 1;
+                    match self.peek() {
+                        Some(b'"') => {
+                            out.push('"');
+                            self.pos += 1;
+                        }
+                        Some(b'\\') => {
+                            out.push('\\');
+                            self.pos += 1;
+                        }
+                        Some(b'/') => {
+                            out.push('/');
+                            self.pos += 1;
+                        }
+                        Some(b'n') => {
+                            out.push('\n');
+                            self.pos += 1;
+                        }
+                        Some(b't') => {
+                            out.push('\t');
+                            self.pos += 1;
+                        }
+                        Some(b'r') => {
+                            out.push('\r');
+                            self.pos += 1;
+                        }
+                        Some(b'b') => {
+                            out.push('\u{8}');
+                            self.pos += 1;
+                        }
+                        Some(b'f') => {
+                            out.push('\u{c}');
+                            self.pos += 1;
+                        }
+                        Some(b'u') => {
+                            self.pos += 1;
+                            let hex = std::str::from_utf8(&self.bytes[self.pos..self.pos + 4])
+                                .map_err(|e| e.to_string())?;
+                            let code = u32::from_str_radix(hex, 16).map_err(|e| e.to_string())?;
+                            self.pos += 4;
+                            if let Some(c) = char::from_u32(code) {
+                                out.push(c);
+                            }
+                        }
+                        other => return Err(format!("bad escape {:?}", other.map(|c| c as char))),
+                    }
+                }
+                Some(_) => {
+                    let start = self.pos;
+                    let rest = std::str::from_utf8(&self.bytes[start..]).map_err(|e| e.to_string())?;
+                    let ch = rest.chars().next().ok_or("empty remainder")?;
+                    out.push(ch);
+                    self.pos += ch.len_utf8();
+                }
+            }
+        }
+        Ok(out)
+    }
+
+    fn parse_number(&mut self) -> Result<Json, String> {
+        let start = self.pos;
+        if self.peek() == Some(b'-') {
+            self.pos += 1;
+        }
+        while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
+            self.pos += 1;
+        }
+        // Fraction and exponent are consumed but dropped: ids and positions are integers.
+        if self.peek() == Some(b'.') {
+            self.pos += 1;
+            while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
+                self.pos += 1;
+            }
+        }
+        if matches!(self.peek(), Some(b'e') | Some(b'E')) {
+            self.pos += 1;
+            if matches!(self.peek(), Some(b'+') | Some(b'-')) {
+                self.pos += 1;
+            }
+            while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
+                self.pos += 1;
+            }
+        }
+        let text = std::str::from_utf8(&self.bytes[start..self.pos]).map_err(|e| e.to_string())?;
+        let int_part = text.split(['.', 'e', 'E']).next().unwrap_or(text);
+        int_part
+            .parse::<i64>()
+            .map(Json::Number)
+            .map_err(|e| format!("bad number {text:?}: {e}"))
+    }
+}
+
+pub fn write(value: &Json) -> String {
+    let mut out = String::new();
+    write_value(&mut out, value);
+    out
+}
+
+fn write_value(out: &mut String, value: &Json) {
+    match value {
+        Json::Null => out.push_str("null"),
+        Json::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
+        Json::Number(n) => {
+            let _ = write!(out, "{n}");
+        }
+        Json::String(s) => write_string(out, s),
+        Json::Array(items) => {
+            out.push('[');
+            for (idx, item) in items.iter().enumerate() {
+                if idx > 0 {
+                    out.push(',');
+                }
+                write_value(out, item);
+            }
+            out.push(']');
+        }
+        Json::Object(pairs) => {
+            out.push('{');
+            for (idx, (key, val)) in pairs.iter().enumerate() {
+                if idx > 0 {
+                    out.push(',');
+                }
+                write_string(out, key);
+                out.push(':');
+                write_value(out, val);
+            }
+            out.push('}');
+        }
+    }
+}
+
+fn write_string(out: &mut String, text: &str) {
+    out.push('"');
+    for ch in text.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\t' => out.push_str("\\t"),
+            '\r' => out.push_str("\\r"),
+            c if (c as u32) < 0x20 => {
+                let _ = write!(out, "\\u{:04x}", c as u32);
+            }
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trips_a_request() {
+        let text = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}"#;
+        let value = Json::parse(text).expect("parses");
+        assert_eq!(value.get("method").and_then(Json::as_str), Some("initialize"));
+        assert_eq!(value.get("id"), Some(&Json::Number(1)));
+    }
+
+    #[test]
+    fn writes_a_diagnostic_object_compactly() {
+        let value = Json::object(vec![
+            ("line", Json::Number(3)),
+            ("message", Json::string("boom")),
+            ("ok", Json::Bool(true)),
+        ]);
+        assert_eq!(write(&value), r#"{"line":3,"message":"boom","ok":true}"#);
+    }
+}