nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-12 20:16:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run rustfmt on the code

Browse Source
This commit is contained in:
Gaëtan Cassiers 2015-07-03 11:13:28 +02:00
parent 3de366d282
commit 990a123e1c
10 changed files with 147 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/changes.rs
View File

@ -35,11 +35,9 @@ pub struct ChangeSet<'a> {
impl<'a> ChangeSet<'a> {
// Create a new ChangeSet for a given libsyntax CodeMap.
pub fn from_codemap(codemap: &'a CodeMap) -> ChangeSet<'a> {
let mut result = ChangeSet {
file_map: HashMap::new(),
codemap: codemap,
file_spans: Vec::with_capacity(codemap.files.borrow().len()),
};
let mut result = ChangeSet { file_map: HashMap::new(),
codemap: codemap,
file_spans: Vec::with_capacity(codemap.files.borrow().len()), };
for f in codemap.files.borrow().iter() {
// Use the length of the file as a heuristic for how much space we
@ -116,11 +114,7 @@ impl<'a> ChangeSet<'a> {
// Return an iterator over the entire changed text.
pub fn text<'c>(&'c self) -> FileIterator<'c, 'a> {
FileIterator {
change_set: self,
keys: self.file_map.keys().collect(),
cur_key: 0,
}
FileIterator { change_set: self, keys: self.file_map.keys().collect(), cur_key: 0 }
}
// Append a newline to the end of each file.
@ -153,12 +147,11 @@ impl<'a> ChangeSet<'a> {
let text = &self.file_map[filename];
// prints all newlines either as `\n` or as `\r\n`
fn write_system_newlines<T>(
mut writer: T,
text: &StringBuffer,
config: &Config)
-> Result<(), ::std::io::Error>
where T: Write,
fn write_system_newlines<T>(mut writer: T,
text: &StringBuffer,
config: &Config)
-> Result<(), ::std::io::Error>
where T: Write
{
match config.newline_style {
NewlineStyle::Unix => write!(writer, "{}", text),

20
src/comment.rs
View File

@ -24,15 +24,13 @@ pub fn rewrite_comment(orig: &str, block_style: bool, width: usize, offset: usiz
let max_chars = width.checked_sub(closer.len()).unwrap_or(1)
.checked_sub(opener.len()).unwrap_or(1);
let fmt = StringFormat {
opener: "",
closer: "",
line_start: line_start,
line_end: "",
width: max_chars,
offset: offset + opener.len() - line_start.len(),
trim_end: true
};
let fmt = StringFormat { opener: "",
closer: "",
line_start: line_start,
line_end: "",
width: max_chars,
offset: offset + opener.len() - line_start.len(),
trim_end: true, };
let indent_str = make_indent(offset);
let line_breaks = s.chars().filter(|&c| c == '\n').count();
@ -102,8 +100,8 @@ fn format_comments() {
let input = "// comment";
let expected_output = "/* com\n \
* men\n \
* t */";
* men\n \
* t */";
assert_eq!(expected_output, rewrite_comment(input, true, 9, 69));
assert_eq!("/* trimmed */", rewrite_comment("/* trimmed */", true, 100, 100));

85
src/expr.rs
View File

@ -63,7 +63,7 @@ fn rewrite_string_lit(context: &RewriteContext,
span: Span,
width: usize,
offset: usize)
-> Option<String> {
-> Option<String> {
// Check if there is anything to fix: we always try to fixup multi-line
// strings, or if the string is too long for the line.
let l_loc = context.codemap.lookup_char_pos(span.lo);
@ -71,15 +71,13 @@ fn rewrite_string_lit(context: &RewriteContext,
if l_loc.line == r_loc.line && r_loc.col.to_usize() <= context.config.max_width {
return context.codemap.span_to_snippet(span).ok();
}
let fmt = StringFormat {
opener: "\"",
closer: "\"",
line_start: " ",
line_end: "\\",
width: width,
offset: offset,
trim_end: false
};
let fmt = StringFormat { opener: "\"",
closer: "\"",
line_start: " ",
line_end: "\\",
width: width,
offset: offset,
trim_end: false, };
Some(rewrite_string(&s.escape_default(), &fmt))
}
@ -90,7 +88,7 @@ fn rewrite_call(context: &RewriteContext,
span: Span,
width: usize,
offset: usize)
-> Option<String> {
-> Option<String> {
debug!("rewrite_call, width: {}, offset: {}", width, offset);
// TODO using byte lens instead of char lens (and probably all over the place too)
@ -119,20 +117,22 @@ fn rewrite_call(context: &RewriteContext,
callee.span.hi + BytePos(1),
span.hi);
let fmt = ListFormatting {
tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: offset,
h_width: remaining_width,
v_width: remaining_width,
ends_with_newline: true,
};
let fmt = ListFormatting { tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: offset,
h_width: remaining_width,
v_width: remaining_width,
ends_with_newline: true, };
Some(format!("{}({})", callee_str, write_list(&items, &fmt)))
}
fn rewrite_paren(context: &RewriteContext, subexpr: &ast::Expr, width: usize, offset: usize) -> Option<String> {
fn rewrite_paren(context: &RewriteContext,
subexpr: &ast::Expr,
width: usize,
offset: usize)
-> Option<String> {
debug!("rewrite_paren, width: {}, offset: {}", width, offset);
// 1 is for opening paren, 2 is for opening+closing, we want to keep the closing
// paren on the same line as the subexpr
@ -148,14 +148,13 @@ fn rewrite_struct_lit<'a>(context: &RewriteContext,
span: Span,
width: usize,
offset: usize)
-> Option<String>
{
-> Option<String> {
debug!("rewrite_struct_lit: width {}, offset {}", width, offset);
assert!(fields.len() > 0 || base.is_some());
enum StructLitField<'a> {
Regular(&'a ast::Field),
Base(&'a ast::Expr)
Base(&'a ast::Expr),
}
let path_str = pprust::path_to_string(path);
@ -203,19 +202,17 @@ fn rewrite_struct_lit<'a>(context: &RewriteContext,
span_after(span, "{", context.codemap),
span.hi);
let fmt = ListFormatting {
tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: if base.is_some() {
let fmt = ListFormatting { tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: if base.is_some() {
SeparatorTactic::Never
} else {
context.config.struct_lit_trailing_comma
},
indent: indent,
h_width: budget,
v_width: budget,
ends_with_newline: true,
};
indent: indent,
h_width: budget,
v_width: budget,
ends_with_newline: true, };
let fields_str = write_list(&items, &fmt);
Some(format!("{} {{ {} }}", path_str, fields_str))
@ -225,7 +222,11 @@ fn rewrite_struct_lit<'a>(context: &RewriteContext,
// }
}
fn rewrite_field(context: &RewriteContext, field: &ast::Field, width: usize, offset: usize) -> Option<String> {
fn rewrite_field(context: &RewriteContext,
field: &ast::Field,
width: usize,
offset: usize)
-> Option<String> {
let name = &token::get_ident(field.ident.node);
let overhead = name.len() + 2;
let expr = field.expr.rewrite(context, width - overhead, offset + overhead);
@ -262,15 +263,13 @@ fn rewrite_tuple_lit(context: &RewriteContext,
SeparatorTactic::Never
};
let fmt = ListFormatting {
tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: trailing_separator_tactic,
indent: indent,
h_width: width - 2,
v_width: width - 2,
ends_with_newline: true,
};
let fmt = ListFormatting { tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: trailing_separator_tactic,
indent: indent,
h_width: width - 2,
v_width: width - 2,
ends_with_newline: true, };
Some(format!("({})", write_list(&items, &fmt)))
}

22
src/imports.rs
View File

@ -48,7 +48,8 @@ impl<'a> FmtVisitor<'a> {
path: &ast::Path,
path_list: &[ast::PathListItem],
visibility: ast::Visibility,
span: Span) -> Option<String> {
span: Span)
-> Option<String> {
let path_str = pprust::path_to_string(path);
let vis = format_visibility(visibility);
@ -70,18 +71,17 @@ impl<'a> FmtVisitor<'a> {
let remaining_line_budget = one_line_budget.checked_sub(used_width).unwrap_or(0);
let remaining_multi_budget = multi_line_budget.checked_sub(used_width).unwrap_or(0);
let fmt = ListFormatting {
tactic: ListTactic::Mixed,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: block_indent + indent,
h_width: remaining_line_budget,
v_width: remaining_multi_budget,
ends_with_newline: true,
};
let fmt = ListFormatting { tactic: ListTactic::Mixed,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: block_indent + indent,
h_width: remaining_line_budget,
v_width: remaining_multi_budget,
ends_with_newline: true, };
let mut items = itemize_list(self.codemap,
vec![ListItem::from_str("")], // Dummy value, explanation below
vec![ListItem::from_str("")], /* Dummy value, explanation
* below */
path_list.iter(),
",",
"}",

35
src/issues.rs
View File

@ -21,7 +21,7 @@ static FIX_ME_CHARS: &'static [char] = &['F', 'I', 'X', 'M', 'E'];
pub enum ReportTactic {
Always,
Unnumbered,
Never
Never,
}
impl ReportTactic {
@ -40,12 +40,12 @@ impl_enum_decodable!(ReportTactic, Always, Unnumbered, Never);
enum Seeking {
Issue {
todo_idx: usize,
fixme_idx: usize
fixme_idx: usize,
},
Number {
issue: Issue,
part: NumberPart
}
part: NumberPart,
},
}
#[derive(Clone, Copy)]
@ -53,7 +53,7 @@ enum NumberPart {
OpenParen,
Pound,
Number,
CloseParen
CloseParen,
}
#[derive(PartialEq, Eq, Debug, Clone, Copy)]
@ -79,13 +79,13 @@ impl fmt::Display for Issue {
#[derive(PartialEq, Eq, Debug, Clone, Copy)]
enum IssueType {
Todo,
Fixme
Fixme,
}
enum IssueClassification {
Good,
Bad(Issue),
None
None,
}
pub struct BadIssueSeeker {
@ -96,11 +96,9 @@ pub struct BadIssueSeeker {
impl BadIssueSeeker {
pub fn new(report_todo: ReportTactic, report_fixme: ReportTactic) -> BadIssueSeeker {
BadIssueSeeker {
state: Seeking::Issue { todo_idx: 0, fixme_idx: 0 },
report_todo: report_todo,
report_fixme: report_fixme,
}
BadIssueSeeker { state: Seeking::Issue { todo_idx: 0, fixme_idx: 0 },
report_todo: report_todo,
report_fixme: report_fixme, }
}
// Check whether or not the current char is conclusive evidence for an
@ -176,8 +174,7 @@ impl BadIssueSeeker {
c: char,
issue: Issue,
mut part: NumberPart)
-> IssueClassification
{
-> IssueClassification {
if ! issue.missing_number || c == '\n' {
return IssueClassification::Bad(issue);
} else if c == ')' {
@ -272,10 +269,7 @@ fn find_issue() {
#[test]
fn issue_type() {
let mut seeker = BadIssueSeeker::new(ReportTactic::Always, ReportTactic::Never);
let expected = Some(Issue {
issue_type: IssueType::Todo,
missing_number: false
});
let expected = Some(Issue { issue_type: IssueType::Todo, missing_number: false });
assert_eq!(expected,
"TODO(#100): more awesomeness".chars()
@ -284,10 +278,7 @@ fn issue_type() {
.unwrap());
let mut seeker = BadIssueSeeker::new(ReportTactic::Never, ReportTactic::Unnumbered);
let expected = Some(Issue {
issue_type: IssueType::Fixme,
missing_number: true
});
let expected = Some(Issue { issue_type: IssueType::Fixme, missing_number: true });
assert_eq!(expected,
"Test. FIXME: bad, bad, not good".chars()

118
src/items.rs
View File

@ -33,8 +33,7 @@ impl<'a> FmtVisitor<'a> {
abi: &abi::Abi,
vis: ast::Visibility,
span: Span)
-> String
{
-> String {
let newline_brace = self.newline_for_brace(&generics.where_clause);
let mut result = self.rewrite_fn_base(indent,
@ -67,8 +66,7 @@ impl<'a> FmtVisitor<'a> {
ident: ast::Ident,
sig: &ast::MethodSig,
span: Span)
-> String
{
-> String {
// Drop semicolon or it will be interpreted as comment
let span = codemap::mk_sp(span.lo, span.hi - BytePos(1));
@ -102,8 +100,7 @@ impl<'a> FmtVisitor<'a> {
vis: ast::Visibility,
span: Span,
newline_brace: bool)
-> String
{
-> String {
// FIXME we'll lose any comments in between parts of the function decl, but anyone
// who comments there probably deserves what they get.
@ -165,9 +162,10 @@ impl<'a> FmtVisitor<'a> {
.last()
.map(|tp| end_typaram(tp))
.unwrap_or(span.lo);
let args_span = codemap::mk_sp(
span_after(codemap::mk_sp(args_start, span.hi), "(", self.codemap),
span_for_return(&fd.output).lo);
let args_span = codemap::mk_sp(span_after(codemap::mk_sp(args_start, span.hi),
"(",
self.codemap),
span_for_return(&fd.output).lo);
result.push_str(&self.rewrite_args(&fd.inputs,
explicit_self,
one_line_budget,
@ -229,8 +227,7 @@ impl<'a> FmtVisitor<'a> {
multi_line_budget: usize,
arg_indent: usize,
span: Span)
-> String
{
-> String {
let mut arg_item_strs: Vec<_> = args.iter().map(|a| self.rewrite_fn_input(a)).collect();
// Account for sugary self.
let mut min_args = 1;
@ -308,15 +305,13 @@ impl<'a> FmtVisitor<'a> {
item.item = arg;
}
let fmt = ListFormatting {
tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: arg_indent,
h_width: one_line_budget,
v_width: multi_line_budget,
ends_with_newline: true,
};
let fmt = ListFormatting { tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: arg_indent,
h_width: one_line_budget,
v_width: multi_line_budget,
ends_with_newline: true, };
write_list(&arg_items, &fmt)
}
@ -326,8 +321,7 @@ impl<'a> FmtVisitor<'a> {
indent: usize,
ret_str_len: usize,
newline_brace: bool)
-> (usize, usize, usize)
{
-> (usize, usize, usize) {
let mut budgets = None;
// Try keeping everything on the same line
@ -384,8 +378,7 @@ impl<'a> FmtVisitor<'a> {
vis: ast::Visibility,
enum_def: &ast::EnumDef,
generics: &ast::Generics,
span: Span)
{
span: Span) {
let header_str = self.format_header("enum ", ident, vis);
self.changes.push_str_span(span, &header_str);
@ -416,11 +409,7 @@ impl<'a> FmtVisitor<'a> {
}
// Variant of an enum
fn visit_variant(&mut self,
field: &ast::Variant,
last_field: bool,
next_span_start: BytePos)
{
fn visit_variant(&mut self, field: &ast::Variant, last_field: bool, next_span_start: BytePos) {
if self.visit_attrs(&field.node.attrs) {
return;
}
@ -511,8 +500,8 @@ impl<'a> FmtVisitor<'a> {
struct_def: &ast::StructDef,
generics: Option<&ast::Generics>,
span: Span,
offset: usize) -> String
{
offset: usize)
-> String {
let mut result = String::with_capacity(1024);
let header_str = self.format_header(item_name, ident, vis);
@ -564,8 +553,7 @@ impl<'a> FmtVisitor<'a> {
// Conservative approximation
let single_line_cost = (span.hi - struct_def.fields[0].span.lo).0;
let break_line = !is_tuple ||
generics_str.contains('\n') ||
let break_line = !is_tuple || generics_str.contains('\n') ||
single_line_cost as usize + used_budget > self.config.max_width;
if break_line {
@ -578,15 +566,13 @@ impl<'a> FmtVisitor<'a> {
// 1 = ,
let budget = self.config.ideal_width - offset + self.config.tab_spaces - 1;
let fmt = ListFormatting {
tactic: tactic,
separator: ",",
trailing_separator: self.config.struct_trailing_comma,
indent: offset + self.config.tab_spaces,
h_width: self.config.max_width,
v_width: budget,
ends_with_newline: false,
};
let fmt = ListFormatting { tactic: tactic,
separator: ",",
trailing_separator: self.config.struct_trailing_comma,
indent: offset + self.config.tab_spaces,
h_width: self.config.max_width,
v_width: budget,
ends_with_newline: false, };
result.push_str(&write_list(&items, &fmt));
@ -609,8 +595,7 @@ impl<'a> FmtVisitor<'a> {
vis: ast::Visibility,
struct_def: &ast::StructDef,
generics: &ast::Generics,
span: Span)
{
span: Span) {
let indent = self.block_indent;
let result = self.format_struct("struct ",
ident,
@ -623,12 +608,7 @@ impl<'a> FmtVisitor<'a> {
self.last_pos = span.hi;
}
fn format_header(&self,
item_name: &str,
ident: ast::Ident,
vis: ast::Visibility)
-> String
{
fn format_header(&self, item_name: &str, ident: ast::Ident, vis: ast::Visibility) -> String {
format!("{}{}{}", format_visibility(vis), item_name, &token::get_ident(ident))
}
@ -637,8 +617,7 @@ impl<'a> FmtVisitor<'a> {
opener: &str,
offset: usize,
span: Span)
-> String
{
-> String {
let mut result = self.rewrite_generics(generics, offset, span);
if generics.where_clause.predicates.len() > 0 || result.contains('\n') {
@ -728,15 +707,13 @@ impl<'a> FmtVisitor<'a> {
item.item = ty;
}
let fmt = ListFormatting {
tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: offset + 1,
h_width: budget,
v_width: budget,
ends_with_newline: true,
};
let fmt = ListFormatting { tactic: ListTactic::HorizontalVertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: offset + 1,
h_width: budget,
v_width: budget,
ends_with_newline: true, };
result.push_str(&write_list(&items, &fmt));
result.push('>');
@ -748,8 +725,7 @@ impl<'a> FmtVisitor<'a> {
where_clause: &ast::WhereClause,
indent: usize,
span_end: BytePos)
-> String
{
-> String {
let mut result = String::new();
if where_clause.predicates.len() == 0 {
return result;
@ -772,15 +748,13 @@ impl<'a> FmtVisitor<'a> {
span_end);
let budget = self.config.ideal_width + self.config.leeway - indent - 10;
let fmt = ListFormatting {
tactic: ListTactic::Vertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: indent + 10,
h_width: budget,
v_width: budget,
ends_with_newline: true,
};
let fmt = ListFormatting { tactic: ListTactic::Vertical,
separator: ",",
trailing_separator: SeparatorTactic::Never,
indent: indent + 10,
h_width: budget,
v_width: budget,
ends_with_newline: true, };
result.push_str(&write_list(&items, &fmt));
result

17
src/lists.rs
View File

@ -48,20 +48,19 @@ pub struct ListFormatting<'a> {
pub v_width: usize,
// Non-expressions, e.g. items, will have a new line at the end of the list.
// Important for comment styles.
pub ends_with_newline: bool
pub ends_with_newline: bool,
}
pub struct ListItem {
pub pre_comment: Option<String>,
// Item should include attributes and doc comments
pub item: String,
pub post_comment: Option<String>
pub post_comment: Option<String>,
}
impl ListItem {
pub fn is_multiline(&self) -> bool {
self.item.contains('\n') ||
self.pre_comment.is_some() ||
self.item.contains('\n') || self.pre_comment.is_some() ||
self.post_comment.as_ref().map(|s| s.contains('\n')).unwrap_or(false)
}
@ -70,11 +69,7 @@ impl ListItem {
}
pub fn from_str<S: Into<String>>(s: S) -> ListItem {
ListItem {
pre_comment: None,
item: s.into(),
post_comment: None
}
ListItem { pre_comment: None, item: s.into(), post_comment: None }
}
}
@ -239,8 +234,8 @@ pub fn itemize_list<T, I, F1, F2, F3>(codemap: &CodeMap,
get_item_string: F3,
mut prev_span_end: BytePos,
next_span_start: BytePos)
-> Vec<ListItem>
where I: Iterator<Item=T>,
-> Vec<ListItem>
where I: Iterator<Item = T>,
F1: Fn(&T) -> BytePos,
F2: Fn(&T) -> BytePos,
F3: Fn(&T) -> String

3
src/missed_spans.rs
View File

@ -36,8 +36,7 @@ impl<'a> FmtVisitor<'a> {
fn format_missing_inner<F: Fn(&mut FmtVisitor, &str, &str, &str)>(&mut self,
end: BytePos,
process_last_snippet: F)
{
process_last_snippet: F) {
let start = self.last_pos;
debug!("format_missing_inner: {:?} to {:?}",
self.codemap.lookup_char_pos(start),

15
src/types.rs
View File

@ -15,8 +15,7 @@ use syntax::parse::token;
use syntax::print::pprust;
impl<'a> FmtVisitor<'a> {
pub fn rewrite_pred(&self, predicate: &ast::WherePredicate) -> String
{
pub fn rewrite_pred(&self, predicate: &ast::WherePredicate) -> String {
// TODO dead spans
// TODO assumes we'll always fit on one line...
match predicate {
@ -49,8 +48,7 @@ impl<'a> FmtVisitor<'a> {
}
}
pub fn rewrite_lifetime_def(&self, lifetime: &ast::LifetimeDef) -> String
{
pub fn rewrite_lifetime_def(&self, lifetime: &ast::LifetimeDef) -> String {
if lifetime.bounds.len() == 0 {
return pprust::lifetime_to_string(&lifetime.lifetime);
}
@ -60,8 +58,7 @@ impl<'a> FmtVisitor<'a> {
lifetime.bounds.iter().map(|l| pprust::lifetime_to_string(l)).collect::<Vec<_>>().connect(" + "))
}
pub fn rewrite_ty_bound(&self, bound: &ast::TyParamBound) -> String
{
pub fn rewrite_ty_bound(&self, bound: &ast::TyParamBound) -> String {
match *bound {
ast::TyParamBound::TraitTyParamBound(ref tref, ast::TraitBoundModifier::None) => {
self.rewrite_poly_trait_ref(tref)
@ -75,8 +72,7 @@ impl<'a> FmtVisitor<'a> {
}
}
pub fn rewrite_ty_param(&self, ty_param: &ast::TyParam) -> String
{
pub fn rewrite_ty_param(&self, ty_param: &ast::TyParam) -> String {
let mut result = String::with_capacity(128);
result.push_str(&token::get_ident(ty_param.ident));
if ty_param.bounds.len() > 0 {
@ -91,8 +87,7 @@ impl<'a> FmtVisitor<'a> {
result
}
fn rewrite_poly_trait_ref(&self, t: &ast::PolyTraitRef) -> String
{
fn rewrite_poly_trait_ref(&self, t: &ast::PolyTraitRef) -> String {
if t.bound_lifetimes.len() > 0 {
format!("for<{}> {}",
t.bound_lifetimes.iter().map(|l| self.rewrite_lifetime_def(l)).collect::<Vec<_>>().connect(", "),

12
src/visitor.rs
View File

@ -282,13 +282,11 @@ impl<'a, 'v> visit::Visitor<'v> for FmtVisitor<'a> {
impl<'a> FmtVisitor<'a> {
pub fn from_codemap<'b>(codemap: &'b CodeMap, config: &'b Config) -> FmtVisitor<'b> {
FmtVisitor {
codemap: codemap,
changes: ChangeSet::from_codemap(codemap),
last_pos: BytePos(0),
block_indent: 0,
config: config
}
FmtVisitor { codemap: codemap,
changes: ChangeSet::from_codemap(codemap),
last_pos: BytePos(0),
block_indent: 0,
config: config, }
}
pub fn snippet(&self, span: Span) -> String {