use super::face::{FaceSyntax, FaceSyntaxError, parse_face, replace_face_macro, source_offset};
pub fn replace_face_region(source: &str, replacement: &str) -> Result<String, FaceSyntaxError> {
let current = parse_face(source)?.ok_or_else(|| FaceSyntaxError {
message: "source has no registration face".to_owned(),
location: None,
})?;
if !current.is_struct_literal() {
return replace_face_macro(source, replacement);
}
let Some((source_start, source_end)) = generated_block(source, ¤t) else {
return replace_face_macro(source, replacement);
};
let next = parse_face(replacement)?.ok_or_else(|| FaceSyntaxError {
message: "replacement has no registration face".to_owned(),
location: None,
})?;
let Some((next_start, next_end)) = generated_block(replacement, &next) else {
return replace_face_macro(source, replacement);
};
let mut output = String::with_capacity(source.len() + (next_end - next_start));
output.push_str(&source[..source_start]);
output.push_str(replacement[next_start..next_end].trim_end());
output.push('\n');
output.push_str(source[source_end..].trim_start_matches('\n'));
Ok(output)
}
fn generated_block(source: &str, face: &FaceSyntax) -> Option<(usize, usize)> {
let (_, spans) = strip_generated_face_items(source, face);
let mut edges: Vec<(usize, usize)> = spans;
let declaration = source_offset(source, &face.declaration_start).ok()?;
let end = source_offset(source, &face.end).ok()?;
edges.push((declaration, end));
let start = edges.iter().map(|&(start, _)| start).min()?;
let end = edges.iter().map(|&(_, end)| end).max()?;
Some((start, end))
}
pub(super) fn strip_generated_face_items(
source: &str,
face: &FaceSyntax,
) -> (String, Vec<(usize, usize)>) {
let mut spans: Vec<(usize, usize)> = Vec::new();
for (needle, closing) in [
("pub const NODE_ID", ';'),
("impl FaceContract for", '}'),
("assert_contracts!", ')'),
] {
let mut from = 0;
while let Some(at) = source[from..].find(needle).map(|offset| from + offset) {
let start = item_start(source, at);
let body = match closing {
'}' | ')' => source[at..]
.find(if closing == '}' { '{' } else { '(' })
.map(|offset| at + offset),
_ => None,
};
let end = match closing {
';' => source[at..].find(';').map(|offset| at + offset + 1),
_ => body.and_then(|open| {
let mut depth = 0i32;
for (offset, character) in source[open..].char_indices() {
if character == if closing == '}' { '{' } else { '(' } {
depth += 1;
} else if character == closing {
depth -= 1;
if depth == 0 {
return Some(open + offset + character.len_utf8());
}
}
}
None
}),
};
let Some(end) = end else {
from = at + needle.len();
continue;
};
let end = if closing == ')' {
source[end..]
.find(';')
.map_or(end, |offset| end + offset + 1)
} else {
end
};
let tail = skip_blank_lines(source, end);
if !source[..start].trim_end().ends_with("pub struct")
&& !is_declaration_start(source, at, face)
{
spans.push((start, tail));
}
from = tail.max(at + needle.len());
}
}
spans.sort_unstable();
spans.dedup();
let mut out = source.to_owned();
for &(start, end) in spans.iter().rev() {
out.replace_range(start..end, "");
}
(out, spans)
}
pub(super) fn item_start(source: &str, at: usize) -> usize {
let mut start = source[..at].rfind('\n').map_or(0, |line| line + 1);
while start > 0 {
let previous_line_end = start - 1;
let previous_line_start = source[..previous_line_end]
.rfind('\n')
.map_or(0, |line| line + 1);
let previous = source[previous_line_start..previous_line_end].trim_start();
if previous.starts_with("///") || previous.starts_with("//!") || previous.starts_with("#[")
{
start = previous_line_start;
} else {
break;
}
}
start
}
pub(super) fn is_declaration_start(source: &str, at: usize, face: &FaceSyntax) -> bool {
let Some(declaration) = source_offset(source, &face.declaration_start).ok() else {
return false;
};
let Some(end) = source_offset(source, &face.end).ok() else {
return false;
};
at >= declaration && at < end
}
pub(super) fn skip_blank_lines(source: &str, from: usize) -> usize {
let mut at = from;
while source[at..].starts_with('\n') {
at += 1;
}
at
}
pub(crate) fn value_start(source: &str, at: usize) -> usize {
let rest = &source[at..];
match rest.find(':') {
Some(colon) => {
let after = &rest[colon + 1..];
at + colon + 1 + (after.len() - after.trim_start().len())
}
None => at,
}
}
pub(crate) fn expression_end(source: &str, start: usize) -> usize {
let mut depth = 0i32;
let mut end = start;
for character in source[start..].chars() {
match character {
'(' | '[' | '{' => depth += 1,
')' | ']' | '}' => {
if depth == 0 {
break;
}
depth -= 1;
}
',' if depth == 0 => break,
_ => {}
}
end += character.len_utf8();
}
let mut start = start;
loop {
let text = &source[start..end];
let trimmed = text.trim_start();
start += text.len() - trimmed.len();
let rest = &source[start..end];
if let Some(after) = rest.strip_prefix("//") {
start += after.find('\n').map_or(rest.len(), |newline| newline + 3);
} else if let Some(after) = rest.strip_prefix("/*") {
start += after.find("*/").map_or(rest.len(), |close| close + 4);
} else {
break;
}
}
loop {
let text = &source[start..end];
let trimmed = text.trim_end();
let removed = text.len() - trimmed.len();
if removed > 0 {
end -= removed;
continue;
}
let rest = &source[start..end];
if let Some(before) = rest.strip_suffix("*/") {
end -= before
.rfind("/*")
.map_or(rest.len(), |open| rest.len() - open);
} else if rest
.lines()
.last()
.is_some_and(|line| line.trim_start().starts_with("//"))
{
end -= rest.lines().last().map_or(0, str::len);
} else {
break;
}
}
end
}