code-atlas 0.2.0

Render local code repositories as architectural treemaps with line-addressed, hierarchically bundled call graphs
Documentation
use anyhow::{Result, bail, ensure};

#[derive(Debug, Default)]
pub(crate) struct ScipIndex {
    pub documents: Vec<ScipDocument>,
}

#[derive(Debug, Default)]
pub(crate) struct ScipDocument {
    pub relative_path: String,
    pub language: String,
    pub position_encoding: i32,
    pub occurrences: Vec<ScipOccurrence>,
}

#[derive(Debug, Default)]
pub(crate) struct ScipOccurrence {
    pub range: Option<ScipRange>,
    pub symbol: String,
    pub symbol_roles: i32,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ScipRange {
    pub start_line: u32,
    pub start_character: u32,
    pub end_line: u32,
    pub end_character: u32,
}

pub(crate) fn decode_index(bytes: &[u8]) -> Result<ScipIndex> {
    let mut reader = ProtoReader::new(bytes);
    let mut index = ScipIndex::default();
    while let Some((field, wire)) = reader.key()? {
        if field == 2 && wire == 2 {
            index.documents.push(decode_document(reader.bytes()?)?);
        } else {
            reader.skip(wire)?;
        }
    }
    Ok(index)
}

fn decode_document(bytes: &[u8]) -> Result<ScipDocument> {
    let mut reader = ProtoReader::new(bytes);
    let mut document = ScipDocument::default();
    while let Some((field, wire)) = reader.key()? {
        match (field, wire) {
            (1, 2) => document.relative_path = reader.string()?,
            (2, 2) => document
                .occurrences
                .push(decode_occurrence(reader.bytes()?)?),
            (4, 2) => document.language = reader.string()?,
            (6, 0) => document.position_encoding = reader.varint()? as i32,
            _ => reader.skip(wire)?,
        }
    }
    Ok(document)
}

fn decode_occurrence(bytes: &[u8]) -> Result<ScipOccurrence> {
    let mut reader = ProtoReader::new(bytes);
    let mut occurrence = ScipOccurrence::default();
    let mut legacy_range = Vec::new();
    while let Some((field, wire)) = reader.key()? {
        match (field, wire) {
            (1, 2) => {
                let mut packed = ProtoReader::new(reader.bytes()?);
                while !packed.finished() {
                    legacy_range.push(packed.varint()? as u32);
                }
            }
            (1, 0) => legacy_range.push(reader.varint()? as u32),
            (2, 2) => occurrence.symbol = reader.string()?,
            (3, 0) => occurrence.symbol_roles = reader.varint()? as i32,
            (8, 2) => occurrence.range = Some(decode_single_line_range(reader.bytes()?)?),
            (9, 2) => occurrence.range = Some(decode_multi_line_range(reader.bytes()?)?),
            _ => reader.skip(wire)?,
        }
    }
    if occurrence.range.is_none() {
        occurrence.range = match legacy_range.as_slice() {
            [line, start, end] => Some(ScipRange {
                start_line: *line,
                start_character: *start,
                end_line: *line,
                end_character: *end,
            }),
            [start_line, start, end_line, end] => Some(ScipRange {
                start_line: *start_line,
                start_character: *start,
                end_line: *end_line,
                end_character: *end,
            }),
            _ => None,
        };
    }
    Ok(occurrence)
}

fn decode_single_line_range(bytes: &[u8]) -> Result<ScipRange> {
    let mut reader = ProtoReader::new(bytes);
    let mut line = 0;
    let mut start = 0;
    let mut end = 0;
    while let Some((field, wire)) = reader.key()? {
        match (field, wire) {
            (1, 0) => line = reader.varint()? as u32,
            (2, 0) => start = reader.varint()? as u32,
            (3, 0) => end = reader.varint()? as u32,
            _ => reader.skip(wire)?,
        }
    }
    Ok(ScipRange {
        start_line: line,
        start_character: start,
        end_line: line,
        end_character: end,
    })
}

fn decode_multi_line_range(bytes: &[u8]) -> Result<ScipRange> {
    let mut reader = ProtoReader::new(bytes);
    let mut range = ScipRange {
        start_line: 0,
        start_character: 0,
        end_line: 0,
        end_character: 0,
    };
    while let Some((field, wire)) = reader.key()? {
        match (field, wire) {
            (1, 0) => range.start_line = reader.varint()? as u32,
            (2, 0) => range.start_character = reader.varint()? as u32,
            (3, 0) => range.end_line = reader.varint()? as u32,
            (4, 0) => range.end_character = reader.varint()? as u32,
            _ => reader.skip(wire)?,
        }
    }
    Ok(range)
}

struct ProtoReader<'a> {
    bytes: &'a [u8],
    offset: usize,
}

impl<'a> ProtoReader<'a> {
    fn new(bytes: &'a [u8]) -> Self {
        Self { bytes, offset: 0 }
    }

    fn finished(&self) -> bool {
        self.offset == self.bytes.len()
    }

    fn key(&mut self) -> Result<Option<(u32, u8)>> {
        if self.finished() {
            return Ok(None);
        }
        let key = self.varint()?;
        let field = (key >> 3) as u32;
        let wire = (key & 0x07) as u8;
        ensure!(field != 0, "SCIP protobuf contains field zero");
        Ok(Some((field, wire)))
    }

    fn varint(&mut self) -> Result<u64> {
        let mut value = 0_u64;
        for shift in (0..70).step_by(7) {
            let Some(byte) = self.bytes.get(self.offset).copied() else {
                bail!("truncated SCIP protobuf varint");
            };
            self.offset += 1;
            value |= u64::from(byte & 0x7f) << shift;
            if byte & 0x80 == 0 {
                return Ok(value);
            }
        }
        bail!("SCIP protobuf varint is too long")
    }

    fn bytes(&mut self) -> Result<&'a [u8]> {
        let length = usize::try_from(self.varint()?)?;
        let end = self
            .offset
            .checked_add(length)
            .ok_or_else(|| anyhow::anyhow!("SCIP protobuf length overflow"))?;
        ensure!(end <= self.bytes.len(), "truncated SCIP protobuf field");
        let value = &self.bytes[self.offset..end];
        self.offset = end;
        Ok(value)
    }

    fn string(&mut self) -> Result<String> {
        Ok(std::str::from_utf8(self.bytes()?)?.to_owned())
    }

    fn skip(&mut self, wire: u8) -> Result<()> {
        match wire {
            0 => {
                self.varint()?;
            }
            1 => self.advance(8)?,
            2 => {
                self.bytes()?;
            }
            5 => self.advance(4)?,
            _ => bail!("unsupported SCIP protobuf wire type {wire}"),
        }
        Ok(())
    }

    fn advance(&mut self, count: usize) -> Result<()> {
        self.offset = self
            .offset
            .checked_add(count)
            .ok_or_else(|| anyhow::anyhow!("SCIP protobuf offset overflow"))?;
        ensure!(
            self.offset <= self.bytes.len(),
            "truncated SCIP protobuf field"
        );
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn field(field: u8, payload: &[u8]) -> Vec<u8> {
        let mut encoded = vec![(field << 3) | 2, payload.len() as u8];
        encoded.extend_from_slice(payload);
        encoded
    }

    #[test]
    fn decodes_documents_occurrences_and_typed_ranges() {
        let typed_range = vec![8, 4, 16, 2, 24, 7];
        let mut occurrence = field(8, &typed_range);
        occurrence.extend(field(2, b"rust cargo demo 1.0 crate/run()."));
        occurrence.extend([24, 1]);
        let mut document = field(1, b"src/main.rs");
        document.extend(field(2, &occurrence));
        document.extend(field(4, b"rust"));
        document.extend([48, 1]);
        let index = decode_index(&field(2, &document)).unwrap();

        assert_eq!(index.documents.len(), 1);
        let document = &index.documents[0];
        assert_eq!(document.relative_path, "src/main.rs");
        assert_eq!(document.language, "rust");
        assert_eq!(document.position_encoding, 1);
        assert_eq!(document.occurrences[0].symbol_roles, 1);
        assert_eq!(
            document.occurrences[0].range,
            Some(ScipRange {
                start_line: 4,
                start_character: 2,
                end_line: 4,
                end_character: 7,
            })
        );
    }
}