use std::path::PathBuf;
use cpp_parser::SymbolKind;
use cpp_parser::{MacroBody, SourceRange};
use crate::cache::SummaryKey;
use crate::index::CookedFile;
use crate::preprocess::directive::IncludeForm;
use crate::summary::CookedDiagnostic;
use crate::summary::{
Access, ConditionalRegion, DeclFact, DeclKind, FactGuard, FileSummary, GuardBranch,
IncludeFact, MacroFact, MacroKind, MacroScopeReading, ModuleReading, SummaryGuards,
TranslationUnit, TuEvent, TuFrame,
};
const MAGIC: &[u8; 8] = b"CPPLSSUM";
pub const CODEC_VERSION: u32 = 36;
pub fn encode(summary: &FileSummary) -> Vec<u8> {
let mut out = Vec::with_capacity(256 + summary.declarations.len() * 48);
out.extend_from_slice(MAGIC);
put_u32(&mut out, CODEC_VERSION);
put_u32(&mut out, summary.key.format_version);
put_u64(&mut out, summary.key.content_hash);
put_u64(&mut out, summary.key.context_hash);
put_u64(&mut out, summary.key.env_hash);
put_u64(&mut out, summary.key.reading_fingerprint);
put_path(&mut out, &summary.path);
put_u32(&mut out, summary.declarations.len() as u32);
for fact in &summary.declarations {
put_declaration(&mut out, fact);
}
put_u32(&mut out, summary.macros.len() as u32);
for fact in &summary.macros {
put_macro(&mut out, fact);
}
put_u32(&mut out, summary.includes.len() as u32);
for fact in &summary.includes {
put_u8(&mut out, include_form_code(fact.form));
put_str(&mut out, &fact.spelling);
put_u8(&mut out, u8::from(fact.is_next));
match &fact.resolved {
Some(path) => {
put_u8(&mut out, 1);
put_path(&mut out, path);
}
None => put_u8(&mut out, 0),
}
put_range(&mut out, fact.range);
put_u32(&mut out, guard_code(fact.guard));
}
put_u32(&mut out, summary.guards.regions.len() as u32);
for region in &summary.guards.regions {
put_range(&mut out, *region);
}
put_u32(&mut out, summary.guards.conditionals.len() as u32);
for conditional in &summary.guards.conditionals {
put_u32(&mut out, conditional.branches.len() as u32);
for branch in &conditional.branches {
put_u8(&mut out, conditional_kind_code(branch.kind));
put_opt_str(&mut out, branch.condition.as_deref());
put_range(&mut out, branch.body);
put_range(&mut out, branch.range);
}
put_u32(&mut out, conditional.parent.unwrap_or(u32::MAX));
}
put_u32(&mut out, summary.guards.own_guard.unwrap_or(u32::MAX));
put_u32(&mut out, summary.macro_readings.len() as u32);
for reading in &summary.macro_readings {
put_range(&mut out, reading.range);
put_str(&mut out, &reading.name);
put_str(&mut out, &reading.body);
match &reading.opens {
Some(segments) => {
put_u8(&mut out, 1);
put_u32(&mut out, segments.len() as u32);
for segment in segments {
put_str(&mut out, segment);
}
}
None => put_u8(&mut out, 0),
}
}
put_opt_str(&mut out, summary.modules.module.as_deref());
put_opt_str(&mut out, summary.modules.partition.as_deref());
put_u8(&mut out, u8::from(summary.modules.is_interface));
put_u32(&mut out, summary.modules.imports.len() as u32);
for imported in &summary.modules.imports {
put_str(&mut out, imported);
}
put_u32(&mut out, summary.modules.header_units.len() as u32);
for unit in &summary.modules.header_units {
put_path(&mut out, unit);
}
put_u32(&mut out, summary.modules.partitions.len() as u32);
for unit in &summary.modules.partitions {
put_path(&mut out, unit);
}
put_u32(&mut out, summary.use_filter.len() as u32);
out.extend_from_slice(&summary.use_filter);
out
}
pub fn encode_translation_unit(
unit: &TranslationUnit,
closure: &[(std::path::PathBuf, u64)],
) -> Vec<u8> {
let mut out = Vec::with_capacity(64 + unit.events.len() * 24);
out.extend_from_slice(MAGIC);
put_u32(&mut out, CODEC_VERSION);
put_u32(&mut out, crate::FORMAT_VERSION);
put_u64(&mut out, crate::READING_FINGERPRINT);
put_u32(&mut out, closure.len() as u32);
for (path, hash) in closure {
put_path(&mut out, path);
put_u64(&mut out, *hash);
}
put_u32(&mut out, unit.conditional_facts as u32);
put_u32(&mut out, unit.facts_in_force as u32);
put_u32(&mut out, unit.frames.len() as u32);
for frame in &unit.frames {
put_path(&mut out, &frame.file);
match frame.parent {
Some(parent) => {
put_u8(&mut out, 1);
put_u32(&mut out, parent);
}
None => put_u8(&mut out, 0),
}
put_u64(&mut out, frame.from_in_parent as u64);
put_u32(&mut out, frame.entry_seq);
put_u32(&mut out, frame.tout);
put_u8(&mut out, u8::from(frame.visit_once));
}
put_u32(&mut out, unit.events.len() as u32);
for event in &unit.events {
put_str(&mut out, &event.name);
match event.function_like {
None => put_u8(&mut out, 0),
Some(false) => put_u8(&mut out, 1),
Some(true) => put_u8(&mut out, 2),
}
match event.body {
Some(body) => {
put_u8(&mut out, 1);
put_u8(&mut out, macro_body_code(body));
}
None => put_u8(&mut out, 0),
}
put_opt_str(&mut out, event.body_text.as_deref());
put_opt_str(&mut out, event.parameters.as_deref());
match event.body_range {
Some(range) => {
put_u8(&mut out, 1);
put_u64(&mut out, range.start_offset as u64);
put_u64(&mut out, range.length as u64);
}
None => put_u8(&mut out, 0),
}
put_u32(&mut out, event.frame);
put_u64(&mut out, event.at as u64);
put_u8(&mut out, u8::from(event.unconditional));
}
out
}
pub fn decode_translation_unit(
bytes: &[u8],
) -> Result<(TranslationUnit, Vec<(std::path::PathBuf, u64)>), DecodeError> {
let mut reader = Reader::new(bytes);
if reader.take(MAGIC.len())? != MAGIC {
return Err(DecodeError::NotASummary);
}
if reader.u32()? != CODEC_VERSION {
return Err(DecodeError::UnsupportedVersion);
}
if reader.u32()? != crate::FORMAT_VERSION {
return Err(DecodeError::UnsupportedVersion);
}
if reader.u64()? != crate::READING_FINGERPRINT {
return Err(DecodeError::UnsupportedVersion);
}
let mut closure = Vec::new();
for _ in 0..reader.count()? {
let path = reader.path()?;
closure.push((path, reader.u64()?));
}
let conditional_facts = reader.u32()? as usize;
let facts_in_force = reader.u32()? as usize;
let frame_count = reader.count()?;
let mut frames = Vec::with_capacity(frame_count);
for _ in 0..frame_count {
let file = reader.path()?;
let parent = match reader.u8()? {
0 => None,
1 => Some(reader.u32()?),
_ => return Err(DecodeError::BadDiscriminant),
};
frames.push(TuFrame {
file,
parent,
from_in_parent: reader.u64()? as usize,
entry_seq: reader.u32()?,
tout: reader.u32()?,
visit_once: reader.u8()? != 0,
});
}
let event_count = reader.count()?;
let mut events = Vec::with_capacity(event_count);
for _ in 0..event_count {
let name: std::sync::Arc<str> = std::sync::Arc::from(reader.string()?);
let function_like = match reader.u8()? {
0 => None,
1 => Some(false),
2 => Some(true),
_ => return Err(DecodeError::BadDiscriminant),
};
let body = match reader.u8()? {
0 => None,
1 => Some(macro_body_from(reader.u8()?)?),
_ => return Err(DecodeError::BadDiscriminant),
};
let body_text = reader.optional_string()?.map(std::sync::Arc::from);
let parameters = reader.optional_string()?.map(std::sync::Arc::from);
let body_range = match reader.u8()? {
0 => None,
1 => Some(cpp_parser::SourceRange::new(
reader.u64()? as usize,
reader.u64()? as usize,
)),
_ => return Err(DecodeError::BadDiscriminant),
};
let frame = reader.u32()?;
let at = reader.u64()? as usize;
let unconditional = match reader.u8()? {
0 => false,
1 => true,
_ => return Err(DecodeError::BadDiscriminant),
};
if frame as usize >= frames.len() {
return Err(DecodeError::BadDiscriminant);
}
events.push(TuEvent {
name,
function_like,
body,
body_text,
parameters,
body_range,
frame,
at,
unconditional,
});
}
if !reader.is_empty() {
return Err(DecodeError::TrailingBytes);
}
Ok((
TranslationUnit::from_parts(events, frames, conditional_facts, facts_in_force),
closure,
))
}
pub fn is_servable(header: &[u8]) -> bool {
let mut reader = Reader::new(header);
let Ok(magic) = reader.take(MAGIC.len()) else {
return false;
};
if magic != MAGIC {
return false;
}
matches!(
(reader.u32(), reader.u32(), reader.u64(), reader.u64(), reader.u64()),
(Ok(codec), Ok(format), Ok(_), Ok(_), Ok(fingerprint))
if codec == CODEC_VERSION
&& format == crate::FORMAT_VERSION
&& fingerprint == crate::READING_FINGERPRINT
)
}
pub const HEADER_LENGTH: usize = 8 + 4 + 4 + 8 + 8 + 8 + 8;
pub fn decode(bytes: &[u8]) -> Result<FileSummary, DecodeError> {
let mut reader = Reader::new(bytes);
if reader.take(MAGIC.len())? != MAGIC {
return Err(DecodeError::NotASummary);
}
if reader.u32()? != CODEC_VERSION {
return Err(DecodeError::UnsupportedVersion);
}
let key = SummaryKey {
format_version: reader.u32()?,
content_hash: reader.u64()?,
context_hash: reader.u64()?,
env_hash: reader.u64()?,
reading_fingerprint: reader.u64()?,
};
let path = reader.path()?;
let mut declarations: Vec<DeclFact> = Vec::new();
for _ in 0..reader.count()? {
declarations.push(get_declaration(&mut reader)?);
}
let mut macros: Vec<MacroFact> = Vec::new();
for _ in 0..reader.count()? {
macros.push(get_macro(&mut reader)?);
}
let mut includes = Vec::new();
for _ in 0..reader.count()? {
let form = include_form_from(reader.u8()?)?;
let spelling = reader.string()?;
let is_next = match reader.u8()? {
0 => false,
1 => true,
_ => return Err(DecodeError::BadDiscriminant),
};
let resolved = match reader.u8()? {
0 => None,
1 => Some(reader.path()?),
_ => return Err(DecodeError::BadDiscriminant),
};
includes.push(IncludeFact {
form,
spelling,
resolved,
is_next,
range: reader.range()?,
guard: guard_from(reader.u32()?)?,
});
}
let mut guards = SummaryGuards::default();
for _ in 0..reader.count()? {
guards.regions.push(reader.range()?);
}
for _ in 0..reader.count()? {
let mut branches = Vec::new();
for _ in 0..reader.count()? {
branches.push(GuardBranch {
kind: conditional_kind_from(reader.u8()?)?,
condition: reader.optional_string()?.map(Box::from),
body: reader.range()?,
range: reader.range()?,
});
}
guards.conditionals.push(ConditionalRegion {
branches,
parent: match reader.u32()? {
u32::MAX => None,
parent => Some(parent),
},
decoded: std::sync::OnceLock::new(),
});
}
guards.own_guard = match reader.u32()? {
u32::MAX => None,
region => Some(region),
};
let mut macro_readings = Vec::new();
for _ in 0..reader.count()? {
let range = reader.range()?;
let name = reader.string()?;
let body = reader.string()?;
let opens = match reader.u8()? {
0 => None,
1 => {
let mut segments = Vec::new();
for _ in 0..reader.count()? {
segments.push(reader.string()?);
}
Some(segments)
}
_ => return Err(DecodeError::BadDiscriminant),
};
macro_readings.push(MacroScopeReading {
range,
name,
body,
opens,
});
}
let modules = ModuleReading {
module: reader.optional_string()?.map(Box::from),
partition: reader.optional_string()?.map(Box::from),
is_interface: reader.u8()? != 0,
imports: {
let mut imports = Vec::new();
for _ in 0..reader.count()? {
imports.push(Box::from(reader.string()?.as_str()));
}
imports
},
header_units: {
let mut units = Vec::new();
for _ in 0..reader.count()? {
units.push(reader.path()?);
}
units
},
partitions: {
let mut units = Vec::new();
for _ in 0..reader.count()? {
units.push(reader.path()?);
}
units
},
};
let use_filter = {
let length = reader.count()?;
let mut bytes = Vec::with_capacity(length.min(64 * 1024));
for _ in 0..length {
bytes.push(reader.u8()?);
}
bytes
};
if !reader.is_empty() {
return Err(DecodeError::TrailingBytes);
}
Ok(FileSummary {
path,
key,
declarations,
macros,
includes,
guards,
macro_readings,
use_filter,
modules,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DecodeError {
NotASummary,
UnsupportedVersion,
Truncated,
Implausible,
BadDiscriminant,
TrailingBytes,
}
impl std::fmt::Display for DecodeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let text = match self {
DecodeError::NotASummary => "not a summary file",
DecodeError::UnsupportedVersion => "summary written by another format version",
DecodeError::Truncated => "summary is truncated",
DecodeError::Implausible => "summary declares more data than it contains",
DecodeError::BadDiscriminant => "summary holds a value outside its vocabulary",
DecodeError::TrailingBytes => "summary has bytes left over",
};
f.write_str(text)
}
}
impl std::error::Error for DecodeError {}
struct Reader<'a> {
bytes: &'a [u8],
at: usize,
}
impl<'a> Reader<'a> {
fn new(bytes: &'a [u8]) -> Self {
Reader { bytes, at: 0 }
}
fn is_empty(&self) -> bool {
self.at >= self.bytes.len()
}
fn take(&mut self, count: usize) -> Result<&'a [u8], DecodeError> {
let end = self.at.checked_add(count).ok_or(DecodeError::Implausible)?;
let slice = self.bytes.get(self.at..end).ok_or(DecodeError::Truncated)?;
self.at = end;
Ok(slice)
}
fn u8(&mut self) -> Result<u8, DecodeError> {
Ok(self.take(1)?[0])
}
fn u32(&mut self) -> Result<u32, DecodeError> {
let bytes = self.take(4)?;
Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
}
fn u64(&mut self) -> Result<u64, DecodeError> {
let bytes = self.take(8)?;
Ok(u64::from_le_bytes([
bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
]))
}
fn count(&mut self) -> Result<usize, DecodeError> {
let count = self.u32()? as usize;
if count > self.bytes.len() - self.at {
return Err(DecodeError::Implausible);
}
Ok(count)
}
fn string(&mut self) -> Result<String, DecodeError> {
let length = self.count()?;
let bytes = self.take(length)?;
String::from_utf8(bytes.to_vec()).map_err(|_| DecodeError::BadDiscriminant)
}
fn optional_string(&mut self) -> Result<Option<String>, DecodeError> {
match self.u8()? {
0 => Ok(None),
1 => self.string().map(Some),
_ => Err(DecodeError::BadDiscriminant),
}
}
fn path(&mut self) -> Result<PathBuf, DecodeError> {
let length = self.count()?;
let bytes = self.take(length)?;
Ok(path_from_bytes(bytes))
}
fn range(&mut self) -> Result<SourceRange, DecodeError> {
let start = self.u64()? as usize;
let length = self.u64()? as usize;
Ok(SourceRange::new(start, length))
}
}
#[cfg(unix)]
fn path_from_bytes(bytes: &[u8]) -> PathBuf {
use std::os::unix::ffi::OsStrExt;
PathBuf::from(std::ffi::OsStr::from_bytes(bytes))
}
#[cfg(not(unix))]
fn path_from_bytes(bytes: &[u8]) -> PathBuf {
PathBuf::from(String::from_utf8_lossy(bytes).into_owned())
}
fn put_u8(out: &mut Vec<u8>, value: u8) {
out.push(value);
}
fn put_u32(out: &mut Vec<u8>, value: u32) {
out.extend_from_slice(&value.to_le_bytes());
}
fn put_u64(out: &mut Vec<u8>, value: u64) {
out.extend_from_slice(&value.to_le_bytes());
}
fn put_str(out: &mut Vec<u8>, value: &str) {
put_u32(out, value.len() as u32);
out.extend_from_slice(value.as_bytes());
}
fn put_opt_str(out: &mut Vec<u8>, value: Option<&str>) {
match value {
Some(text) => {
put_u8(out, 1);
put_str(out, text);
}
None => put_u8(out, 0),
}
}
fn put_range(out: &mut Vec<u8>, range: SourceRange) {
put_u64(out, range.start_offset as u64);
put_u64(out, range.length as u64);
}
#[cfg(unix)]
fn put_path(out: &mut Vec<u8>, path: &std::path::Path) {
use std::os::unix::ffi::OsStrExt;
let bytes = path.as_os_str().as_bytes();
put_u32(out, bytes.len() as u32);
out.extend_from_slice(bytes);
}
#[cfg(not(unix))]
fn put_path(out: &mut Vec<u8>, path: &std::path::Path) {
put_str(out, &path.to_string_lossy());
}
fn decl_kind_code(kind: DeclKind) -> u8 {
match kind {
DeclKind::Type => 1,
DeclKind::Function => 2,
DeclKind::Variable => 3,
DeclKind::Namespace => 4,
DeclKind::MacroLike => 5,
DeclKind::Other => 6,
}
}
fn decl_kind_from(code: u8) -> Result<DeclKind, DecodeError> {
Ok(match code {
1 => DeclKind::Type,
2 => DeclKind::Function,
3 => DeclKind::Variable,
4 => DeclKind::Namespace,
5 => DeclKind::MacroLike,
6 => DeclKind::Other,
_ => return Err(DecodeError::BadDiscriminant),
})
}
fn macro_kind_code(kind: MacroKind) -> u8 {
match kind {
MacroKind::Definition => 1,
MacroKind::Undefinition => 2,
}
}
fn conditional_kind_code(kind: crate::DirectiveKind) -> u8 {
match kind {
crate::DirectiveKind::If => 1,
crate::DirectiveKind::Ifdef => 2,
crate::DirectiveKind::Ifndef => 3,
crate::DirectiveKind::Elif => 4,
crate::DirectiveKind::Else => 5,
_ => 0,
}
}
fn conditional_kind_from(code: u8) -> Result<crate::DirectiveKind, DecodeError> {
Ok(match code {
1 => crate::DirectiveKind::If,
2 => crate::DirectiveKind::Ifdef,
3 => crate::DirectiveKind::Ifndef,
4 => crate::DirectiveKind::Elif,
5 => crate::DirectiveKind::Else,
_ => return Err(DecodeError::BadDiscriminant),
})
}
fn macro_kind_from(code: u8) -> Result<MacroKind, DecodeError> {
Ok(match code {
1 => MacroKind::Definition,
2 => MacroKind::Undefinition,
_ => return Err(DecodeError::BadDiscriminant),
})
}
fn guard_code(guard: FactGuard) -> u32 {
match guard {
FactGuard::Unconditional => u32::MAX,
FactGuard::Region(index) => index,
}
}
fn guard_from(code: u32) -> Result<FactGuard, DecodeError> {
Ok(match code {
u32::MAX => FactGuard::Unconditional,
index => FactGuard::Region(index),
})
}
fn access_code(access: Option<Access>) -> u8 {
match access {
None => 0,
Some(Access::Public) => 1,
Some(Access::Protected) => 2,
Some(Access::Private) => 3,
}
}
fn access_from(code: u8) -> Option<Access> {
match code {
1 => Some(Access::Public),
2 => Some(Access::Protected),
3 => Some(Access::Private),
_ => None,
}
}
fn macro_body_code(body: MacroBody) -> u8 {
match body {
MacroBody::Specifier => 1,
MacroBody::Statement => 2,
MacroBody::Block => 3,
MacroBody::Expression => 4,
MacroBody::Type => 5,
MacroBody::Unknown => 6,
}
}
fn macro_body_from(code: u8) -> Result<MacroBody, DecodeError> {
Ok(match code {
1 => MacroBody::Specifier,
2 => MacroBody::Statement,
3 => MacroBody::Block,
4 => MacroBody::Expression,
5 => MacroBody::Type,
6 => MacroBody::Unknown,
_ => return Err(DecodeError::BadDiscriminant),
})
}
fn include_form_code(form: IncludeForm) -> u8 {
match form {
IncludeForm::Angle => 1,
IncludeForm::Quote => 2,
IncludeForm::Macro => 3,
}
}
fn include_form_from(code: u8) -> Result<IncludeForm, DecodeError> {
Ok(match code {
1 => IncludeForm::Angle,
2 => IncludeForm::Quote,
3 => IncludeForm::Macro,
_ => return Err(DecodeError::BadDiscriminant),
})
}
#[allow(dead_code)]
fn symbol_kind_code(kind: SymbolKind) -> u8 {
match kind {
SymbolKind::Type => 1,
SymbolKind::Template => 2,
SymbolKind::Macro { .. } => 3,
SymbolKind::Function => 4,
SymbolKind::Variable => 5,
SymbolKind::Namespace => 6,
}
}
#[cfg(test)]
mod tests {
use super::{CODEC_VERSION, DecodeError, MAGIC, decl_kind_code, decode, encode};
use crate::cache::SummaryKey;
use crate::preprocess::directive::IncludeForm;
use crate::summary::MacroKind;
use crate::summary::{
ConditionalRegion, DeclFact, DeclKind, FactGuard, FileSummary, GuardBranch, IncludeFact,
MacroFact, MacroScopeReading, SummaryGuards,
};
use cpp_parser::{MacroBody, SourceRange};
fn range(start: usize, length: usize) -> SourceRange {
SourceRange::new(start, length)
}
fn every_field() -> FileSummary {
FileSummary {
path: std::path::PathBuf::from("/project/src/widget.cpp"),
key: SummaryKey::new(0x1111_2222_3333_4444, 0xaaaa_bbbb_cccc_dddd),
use_filter: vec![0x00, 0xff, 0x55, 0xaa, 0x01, 0x80],
declarations: vec![
DeclFact {
frees: 0,
reflection: Some(crate::summary::ReflectionFact {
macro_name: "UCLASS".to_string(),
specifiers: vec![
"Blueprintable".to_string(),
"Category = \"UI\"".to_string(),
"meta=(DisplayName=\"W\", ToolTip=\"a, b\")".to_string(),
],
}),
name: "Widget".to_string(),
scope: None,
kind: DeclKind::Type,
modifiers: crate::DeclModifiers::default(),
type_of: None,
returns: None,
bases: vec!["Base".to_string(), "ns::Other".to_string()],
parameters: vec!["_Ty".to_string(), "_Alloc".to_string()],
constraints: vec![String::new(), "Integral".to_string()],
requires_clause: None,
parameter_defaults: Vec::new(),
pattern: Some("Widget<_Ty, _Alloc>".to_string()),
parameter_list: Some("(int, int)".to_string()),
access: Some(super::Access::Protected),
exported: true,
definition: true,
range: range(10, 20),
name_range: range(17, 6),
local: true,
in_namespace: Some("std::ranges".to_string()),
clean: false,
split_by_a_directive: false,
guard: FactGuard::Unconditional,
},
DeclFact {
frees: 0,
reflection: None,
name: "make".to_string(),
scope: Some("ns::Widget".to_string()),
kind: DeclKind::Function,
modifiers: crate::DeclModifiers::default(),
type_of: None,
returns: Some("ns::Container<int>".to_string()),
bases: Vec::new(),
parameters: Vec::new(),
constraints: Vec::new(),
requires_clause: None,
parameter_defaults: Vec::new(),
pattern: None,
parameter_list: Some("()".to_string()),
access: None,
exported: false,
definition: false,
range: range(40, 15),
name_range: range(48, 6),
local: false,
in_namespace: None,
clean: true,
split_by_a_directive: false,
guard: FactGuard::Region(3),
},
DeclFact {
frees: 0,
reflection: None,
name: String::new(),
scope: None,
kind: DeclKind::Other,
modifiers: crate::DeclModifiers::default(),
type_of: None,
returns: None,
bases: Vec::new(),
parameters: Vec::new(),
constraints: Vec::new(),
requires_clause: None,
parameter_defaults: Vec::new(),
pattern: None,
parameter_list: None,
access: None,
exported: false,
definition: false,
range: range(60, 8),
name_range: range(60, 0),
local: false,
in_namespace: None,
clean: true,
split_by_a_directive: false,
guard: FactGuard::Unconditional,
},
],
macros: vec![MacroFact {
name: "MY_API".to_string(),
kind: MacroKind::Definition,
function_like: false,
body: MacroBody::Specifier,
value: Some("1".into()),
alias: Some("OTHER_API".into()),
range: range(80, 30),
body_range: Some(range(95, 12)),
guard: FactGuard::Region(0),
settles_the_name: true,
}],
includes: vec![
IncludeFact {
form: IncludeForm::Angle,
spelling: "vector".to_string(),
resolved: Some(std::path::PathBuf::from("/usr/include/c++/13/vector")),
is_next: false,
range: range(1, 18),
guard: FactGuard::Unconditional,
},
IncludeFact {
form: IncludeForm::Quote,
spelling: "missing.h".to_string(),
resolved: None,
is_next: true,
range: range(120, 20),
guard: FactGuard::Region(1),
},
],
guards: SummaryGuards {
visit_once: false,
regions: vec![
range(200, 12),
range(240, 20),
range(260, 9),
range(300, 11),
],
conditionals: vec![
ConditionalRegion {
branches: vec![
GuardBranch {
kind: crate::DirectiveKind::Ifdef,
condition: Some("_WIN32".into()),
body: range(216, 20),
range: range(200, 12),
},
GuardBranch {
kind: crate::DirectiveKind::Else,
condition: None,
body: range(252, 0),
range: range(240, 20),
},
],
parent: None,
decoded: std::sync::OnceLock::new(),
},
ConditionalRegion {
branches: vec![GuardBranch {
kind: crate::DirectiveKind::If,
condition: Some("__cplusplus >= 201703L".into()),
body: range(275, 20),
range: range(260, 9),
}],
parent: Some(0),
decoded: std::sync::OnceLock::new(),
},
],
own_guard: Some(0),
},
macro_readings: vec![
MacroScopeReading {
range: range(400, 10),
name: "_STD_BEGIN".to_string(),
body: "namespace std {".to_string(),
opens: Some(vec!["std".to_string()]),
},
MacroScopeReading {
range: range(500, 8),
name: "_STD_END".to_string(),
body: "}".to_string(),
opens: None,
},
],
modules: super::ModuleReading {
module: Some("widget.core".into()),
partition: Some("detail".into()),
is_interface: true,
imports: vec!["std".into(), "widget.draw".into()],
header_units: vec![std::path::PathBuf::from("/usr/include/c++/v1/vector")],
partitions: vec![std::path::PathBuf::from("/p/widget-core-detail.cppm")],
},
}
}
#[test]
fn a_summary_with_every_field_round_trips() {
let original = every_field();
let bytes = encode(&original);
let decoded = decode(&bytes).expect("the bytes this module wrote must be readable by it");
assert_eq!(
decoded, original,
"every field survives, including the ones no test above uses"
);
}
#[test]
fn an_empty_summary_round_trips() {
let original = FileSummary::empty("/p/empty.h", SummaryKey::new(0, 0));
let decoded = decode(&encode(&original)).expect("an empty summary is still a summary");
assert_eq!(decoded, original);
assert!(decoded.is_empty());
}
#[test]
fn bytes_that_are_not_a_summary_are_rejected() {
assert_eq!(decode(b"").unwrap_err(), DecodeError::Truncated);
assert_eq!(
decode(b"not a summary at all").unwrap_err(),
DecodeError::NotASummary
);
}
#[test]
fn a_truncated_summary_is_rejected_rather_than_half_read() {
let bytes = encode(&every_field());
for cut in 0..bytes.len() {
if let Ok(partial) = decode(&bytes[..cut]) {
assert!(partial.declarations.len() <= 3);
}
}
}
#[test]
fn a_future_format_version_is_rejected() {
let mut bytes = encode(&every_field());
let version_at = MAGIC.len();
bytes[version_at..version_at + 4].copy_from_slice(&(CODEC_VERSION + 1).to_le_bytes());
assert_eq!(decode(&bytes).unwrap_err(), DecodeError::UnsupportedVersion);
}
#[test]
fn trailing_bytes_are_rejected() {
let mut bytes = encode(&every_field());
bytes.push(0);
assert_eq!(decode(&bytes).unwrap_err(), DecodeError::TrailingBytes);
}
#[test]
fn an_implausible_count_is_rejected_without_allocating() {
let summary = every_field();
let mut bytes = encode(&summary);
let count_at = declaration_count_at(&summary);
bytes[count_at..count_at + 4].copy_from_slice(&u32::MAX.to_le_bytes());
assert_eq!(decode(&bytes).unwrap_err(), DecodeError::Implausible);
}
#[test]
fn a_field_outside_its_vocabulary_is_rejected() {
let summary = every_field();
let mut bytes = encode(&summary);
let kind_at = first_declaration_kind_at(&summary);
assert_eq!(bytes[kind_at], decl_kind_code(summary.declarations[0].kind));
bytes[kind_at] = 99;
assert_eq!(
decode(&bytes).unwrap_err(),
DecodeError::BadDiscriminant,
"a vocabulary byte outside its vocabulary is a reject, not a default"
);
}
fn declaration_count_at(summary: &FileSummary) -> usize {
const HEADER: usize = MAGIC.len() + 4 + 4 + 8 + 8 + 8 + 8;
HEADER + 4 + summary.path.to_string_lossy().len()
}
fn first_declaration_kind_at(summary: &FileSummary) -> usize {
let first = &summary.declarations[0];
let mut at = declaration_count_at(summary) + 4 + 4 + first.name.len();
at += match &first.scope {
Some(scope) => 1 + 4 + scope.len(),
None => 1,
};
at
}
}
fn put_declaration(out: &mut Vec<u8>, fact: &DeclFact) {
put_str(out, &fact.name);
put_opt_str(out, fact.scope.as_deref());
put_u8(out, decl_kind_code(fact.kind));
put_opt_str(out, fact.type_of.as_deref());
put_opt_str(out, fact.returns.as_deref());
put_u32(out, fact.bases.len() as u32);
for base in &fact.bases {
put_str(out, base);
}
put_u32(out, fact.parameters.len() as u32);
for parameter in &fact.parameters {
put_str(out, parameter);
}
put_u32(out, fact.constraints.len() as u32);
for constraint in &fact.constraints {
put_str(out, constraint);
}
put_opt_str(out, fact.requires_clause.as_deref());
put_u32(out, fact.parameter_defaults.len() as u32);
for default in &fact.parameter_defaults {
put_str(out, default);
}
put_opt_str(out, fact.parameter_list.as_deref());
put_opt_str(out, fact.pattern.as_deref());
put_range(out, fact.range);
put_range(out, fact.name_range);
put_u8(out, u8::from(fact.local));
put_opt_str(out, fact.in_namespace.as_deref());
put_u8(out, u8::from(fact.clean));
put_u8(out, u8::from(fact.split_by_a_directive));
put_u32(out, guard_code(fact.guard));
put_u8(out, access_code(fact.access));
put_u8(out, u8::from(fact.exported));
put_u32(out, fact.modifiers.bits());
put_u64(out, fact.frees);
match &fact.reflection {
Some(reflection) => {
put_u8(out, 1);
put_str(out, &reflection.macro_name);
put_u32(out, reflection.specifiers.len() as u32);
for specifier in &reflection.specifiers {
put_str(out, specifier);
}
}
None => put_u8(out, 0),
}
put_u8(out, u8::from(fact.definition));
}
fn put_macro(out: &mut Vec<u8>, fact: &MacroFact) {
put_str(out, &fact.name);
put_u8(out, macro_kind_code(fact.kind));
put_u8(out, u8::from(fact.function_like));
put_u8(out, macro_body_code(fact.body));
put_opt_str(out, fact.value.as_deref());
put_opt_str(out, fact.alias.as_deref());
put_range(out, fact.range);
match fact.body_range {
Some(range) => {
put_u8(out, 1);
put_range(out, range);
}
None => put_u8(out, 0),
}
put_u32(out, guard_code(fact.guard));
put_u8(out, u8::from(fact.settles_the_name));
}
fn get_declaration(reader: &mut Reader<'_>) -> Result<DeclFact, DecodeError> {
Ok(DeclFact {
name: reader.string()?,
scope: reader.optional_string()?,
kind: decl_kind_from(reader.u8()?)?,
type_of: reader.optional_string()?,
returns: reader.optional_string()?,
bases: {
let mut bases = Vec::new();
for _ in 0..reader.count()? {
bases.push(reader.string()?);
}
bases
},
parameters: {
let mut parameters = Vec::new();
for _ in 0..reader.count()? {
parameters.push(reader.string()?);
}
parameters
},
constraints: {
let mut constraints = Vec::new();
for _ in 0..reader.count()? {
constraints.push(reader.string()?);
}
constraints
},
requires_clause: reader.optional_string()?,
parameter_defaults: {
let mut defaults = Vec::new();
for _ in 0..reader.count()? {
defaults.push(reader.string()?);
}
defaults
},
parameter_list: reader.optional_string()?,
pattern: reader.optional_string()?,
range: reader.range()?,
name_range: reader.range()?,
local: reader.u8()? != 0,
in_namespace: reader.optional_string()?,
clean: reader.u8()? != 0,
split_by_a_directive: reader.u8()? != 0,
guard: guard_from(reader.u32()?)?,
access: access_from(reader.u8()?),
exported: reader.u8()? != 0,
modifiers: crate::DeclModifiers::from_bits(reader.u32()?),
frees: reader.u64()?,
reflection: match reader.u8()? {
0 => None,
_ => {
let macro_name = reader.string()?;
let count = reader.count()?;
let mut specifiers = Vec::with_capacity(count);
for _ in 0..count {
specifiers.push(reader.string()?);
}
Some(crate::summary::ReflectionFact {
macro_name,
specifiers,
})
}
},
definition: reader.u8()? != 0,
})
}
fn get_macro(reader: &mut Reader<'_>) -> Result<MacroFact, DecodeError> {
Ok(MacroFact {
name: reader.string()?,
kind: macro_kind_from(reader.u8()?)?,
function_like: reader.u8()? != 0,
body: macro_body_from(reader.u8()?)?,
value: reader.optional_string()?.map(Box::from),
alias: reader.optional_string()?.map(Box::from),
range: reader.range()?,
body_range: match reader.u8()? {
0 => None,
1 => Some(reader.range()?),
_ => return Err(DecodeError::BadDiscriminant),
},
guard: guard_from(reader.u32()?)?,
settles_the_name: reader.u8()? != 0,
})
}
const COOKED_MAGIC: &[u8; 8] = b"CPPLSCKR";
const COOKED_VERSION: u32 = 1;
pub fn encode_the_cooked_reading(reading: &CookedFile) -> Vec<u8> {
let mut out = Vec::with_capacity(256 + reading.declarations.len() * 48);
out.extend_from_slice(COOKED_MAGIC);
put_u32(&mut out, COOKED_VERSION);
put_u32(&mut out, reading.declarations.len() as u32);
for fact in &reading.declarations {
put_declaration(&mut out, fact);
}
put_u32(&mut out, reading.macros.len() as u32);
for fact in &reading.macros {
put_macro(&mut out, fact);
}
put_u32(&mut out, reading.diagnostics.len() as u32);
for diagnostic in &reading.diagnostics {
put_range(&mut out, diagnostic.range);
put_str(&mut out, &diagnostic.message);
}
put_u32(&mut out, reading.unplaced as u32);
out
}
pub fn decode_the_cooked_reading(bytes: &[u8]) -> Result<CookedFile, DecodeError> {
let mut reader = Reader::new(bytes);
if reader.take(COOKED_MAGIC.len())? != COOKED_MAGIC {
return Err(DecodeError::NotASummary);
}
if reader.u32()? != COOKED_VERSION {
return Err(DecodeError::UnsupportedVersion);
}
let mut declarations = Vec::new();
for _ in 0..reader.count()? {
declarations.push(get_declaration(&mut reader)?);
}
let mut macros = Vec::new();
for _ in 0..reader.count()? {
macros.push(get_macro(&mut reader)?);
}
let mut diagnostics = Vec::new();
for _ in 0..reader.count()? {
diagnostics.push(CookedDiagnostic {
range: reader.range()?,
message: reader.string()?,
});
}
let unplaced = reader.u32()? as usize;
Ok(CookedFile {
declarations,
macros,
diagnostics,
unplaced,
})
}
#[test]
fn a_cooked_reading_round_trips() {
let reading = CookedFile {
declarations: vec![
DeclFact {
name: "Widget".to_string(),
scope: Some("std".to_string()),
kind: DeclKind::Type,
type_of: None,
returns: None,
bases: vec!["Base".to_string()],
parameters: vec!["T".to_string()],
constraints: Vec::new(),
requires_clause: Some("sizeof(T) > 0".to_string()),
parameter_defaults: Vec::new(),
parameter_list: None,
pattern: Some("Widget<T>".to_string()),
range: SourceRange::new(10, 20),
name_range: SourceRange::new(16, 6),
local: false,
in_namespace: Some("std".to_string()),
clean: true,
split_by_a_directive: false,
guard: FactGuard::Unconditional,
access: Some(Access::Public),
exported: true,
definition: true,
modifiers: crate::DeclModifiers::default(),
frees: 0,
reflection: Some(crate::summary::ReflectionFact {
macro_name: "UPROPERTY".to_string(),
specifiers: vec!["EditAnywhere".to_string()],
}),
},
DeclFact {
name: "f".to_string(),
scope: None,
kind: DeclKind::Function,
type_of: Some("int".to_string()),
returns: Some("void".to_string()),
bases: Vec::new(),
parameters: Vec::new(),
constraints: vec!["Copyable<T>".to_string()],
requires_clause: None,
parameter_defaults: vec!["0".to_string()],
parameter_list: Some("(int a)".to_string()),
pattern: None,
range: SourceRange::new(40, 30),
name_range: SourceRange::new(44, 1),
local: true,
in_namespace: None,
clean: false,
split_by_a_directive: true,
guard: FactGuard::Unconditional,
access: None,
exported: false,
definition: false,
modifiers: crate::DeclModifiers::default(),
frees: 3,
reflection: None,
},
],
macros: vec![crate::summary::MacroFact {
name: "_STD_BEGIN".to_string(),
kind: crate::summary::MacroKind::Definition,
function_like: false,
body: MacroBody::Expression,
value: Some(Box::from("namespace std {")),
alias: None,
range: SourceRange::new(1, 30),
body_range: Some(SourceRange::new(20, 14)),
guard: FactGuard::Unconditional,
settles_the_name: true,
}],
diagnostics: vec![CookedDiagnostic {
range: SourceRange::new(50, 3),
message: "expected `;`".to_string(),
}],
unplaced: 2,
};
let bytes = encode_the_cooked_reading(&reading);
let back = decode_the_cooked_reading(&bytes).expect("the bytes this encoder wrote decode");
assert_eq!(back.declarations.len(), 2);
assert_eq!(back.declarations[0].name, "Widget");
assert_eq!(back.declarations[0].scope.as_deref(), Some("std"));
assert_eq!(back.declarations[0].bases, ["Base"]);
assert_eq!(
back.declarations[0].requires_clause.as_deref(),
Some("sizeof(T) > 0")
);
assert_eq!(back.declarations[0].pattern.as_deref(), Some("Widget<T>"));
assert_eq!(back.declarations[0].range, SourceRange::new(10, 20));
assert_eq!(back.declarations[0].access, Some(Access::Public));
assert_eq!(
back.declarations[0]
.reflection
.as_ref()
.map(|r| r.macro_name.as_str()),
Some("UPROPERTY")
);
assert_eq!(back.declarations[1].frees, 3);
assert!(back.declarations[1].local);
assert!(back.declarations[1].split_by_a_directive);
assert_eq!(back.macros.len(), 1);
assert_eq!(back.macros[0].name, "_STD_BEGIN");
assert_eq!(back.macros[0].body_range, Some(SourceRange::new(20, 14)));
assert!(back.macros[0].settles_the_name);
assert_eq!(back.diagnostics.len(), 1);
assert_eq!(back.diagnostics[0].message, "expected `;`");
assert_eq!(back.unplaced, 2);
let mut other_record = encode_the_cooked_reading(&reading);
other_record[0] = b'X';
assert!(
decode_the_cooked_reading(&other_record).is_err(),
"a record whose magic is not a cooked reading's is refused"
);
let mut next_layout = encode_the_cooked_reading(&reading);
next_layout[8..12].copy_from_slice(&0u32.to_le_bytes());
assert!(
decode_the_cooked_reading(&next_layout).is_err(),
"and one written by a different layout is refused on its version"
);
}