Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit cf64611

Browse files
vadimcnvadimcn
committedAug 25, 2016
Fix debug line info for macro expansions.
Macro expansions produce code tagged with debug locations that are completely different from the surrounding expressions. This wrecks havoc on debugger's ability the step over source lines. In order to have a good line stepping behavior in debugger, we overwrite debug locations of macro expansions with that of the outermost expansion site.
1 parent e9bc1ba commit cf64611

File tree

11 files changed

+298
-53
lines changed

11 files changed

+298
-53
lines changed
 

‎src/librustc/middle/region.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -237,7 +237,7 @@ impl CodeExtent {
237237
// (This is the special case aluded to in the
238238
// doc-comment for this method)
239239
let stmt_span = blk.stmts[r.first_statement_index as usize].span;
240-
Some(Span { lo: stmt_span.hi, ..blk.span })
240+
Some(Span { lo: stmt_span.hi, hi: blk.span.hi, expn_id: stmt_span.expn_id })
241241
}
242242
}
243243
}

‎src/librustc/session/config.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -891,6 +891,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
891891
"force overflow checks on or off"),
892892
trace_macros: bool = (false, parse_bool, [UNTRACKED],
893893
"for every macro invocation, print its name and arguments"),
894+
debug_macros: bool = (false, parse_bool, [TRACKED],
895+
"emit line numbers debug info inside macros"),
894896
enable_nonzeroing_move_hints: bool = (false, parse_bool, [TRACKED],
895897
"force nonzeroing move optimization on"),
896898
keep_hygiene_data: bool = (false, parse_bool, [UNTRACKED],

‎src/librustc_llvm/ffi.rs

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1796,6 +1796,11 @@ extern {
17961796
Col: c_uint)
17971797
-> DILexicalBlock;
17981798

1799+
pub fn LLVMRustDIBuilderCreateLexicalBlockFile(Builder: DIBuilderRef,
1800+
Scope: DIScope,
1801+
File: DIFile)
1802+
-> DILexicalBlock;
1803+
17991804
pub fn LLVMRustDIBuilderCreateStaticVariable(Builder: DIBuilderRef,
18001805
Context: DIScope,
18011806
Name: *const c_char,

‎src/librustc_trans/debuginfo/create_scope_map.rs

Lines changed: 40 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -25,11 +25,33 @@ use syntax_pos::Pos;
2525
use rustc_data_structures::bitvec::BitVector;
2626
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
2727

28+
use syntax_pos::BytePos;
29+
30+
#[derive(Clone, Copy, Debug)]
31+
pub struct MirDebugScope {
32+
pub scope_metadata: DIScope,
33+
// Start and end offsets of the file to which this DIScope belongs.
34+
// These are used to quickly determine whether some span refers to the same file.
35+
pub file_start_pos: BytePos,
36+
pub file_end_pos: BytePos,
37+
}
38+
39+
impl MirDebugScope {
40+
pub fn is_valid(&self) -> bool {
41+
!self.scope_metadata.is_null()
42+
}
43+
}
44+
2845
/// Produce DIScope DIEs for each MIR Scope which has variables defined in it.
2946
/// If debuginfo is disabled, the returned vector is empty.
30-
pub fn create_mir_scopes(fcx: &FunctionContext) -> IndexVec<VisibilityScope, DIScope> {
47+
pub fn create_mir_scopes(fcx: &FunctionContext) -> IndexVec<VisibilityScope, MirDebugScope> {
3148
let mir = fcx.mir.clone().expect("create_mir_scopes: missing MIR for fn");
32-
let mut scopes = IndexVec::from_elem(ptr::null_mut(), &mir.visibility_scopes);
49+
let null_scope = MirDebugScope {
50+
scope_metadata: ptr::null_mut(),
51+
file_start_pos: BytePos(0),
52+
file_end_pos: BytePos(0)
53+
};
54+
let mut scopes = IndexVec::from_elem(null_scope, &mir.visibility_scopes);
3355

3456
let fn_metadata = match fcx.debug_context {
3557
FunctionDebugContext::RegularContext(box ref data) => data.fn_metadata,
@@ -59,8 +81,8 @@ fn make_mir_scope(ccx: &CrateContext,
5981
has_variables: &BitVector,
6082
fn_metadata: DISubprogram,
6183
scope: VisibilityScope,
62-
scopes: &mut IndexVec<VisibilityScope, DIScope>) {
63-
if !scopes[scope].is_null() {
84+
scopes: &mut IndexVec<VisibilityScope, MirDebugScope>) {
85+
if scopes[scope].is_valid() {
6486
return;
6587
}
6688

@@ -70,7 +92,12 @@ fn make_mir_scope(ccx: &CrateContext,
7092
scopes[parent]
7193
} else {
7294
// The root is the function itself.
73-
scopes[scope] = fn_metadata;
95+
let loc = span_start(ccx, mir.span);
96+
scopes[scope] = MirDebugScope {
97+
scope_metadata: fn_metadata,
98+
file_start_pos: loc.file.start_pos,
99+
file_end_pos: loc.file.end_pos,
100+
};
74101
return;
75102
};
76103

@@ -81,20 +108,25 @@ fn make_mir_scope(ccx: &CrateContext,
81108
// However, we don't skip creating a nested scope if
82109
// our parent is the root, because we might want to
83110
// put arguments in the root and not have shadowing.
84-
if parent_scope != fn_metadata {
111+
if parent_scope.scope_metadata != fn_metadata {
85112
scopes[scope] = parent_scope;
86113
return;
87114
}
88115
}
89116

90117
let loc = span_start(ccx, scope_data.span);
91-
scopes[scope] = unsafe {
92118
let file_metadata = file_metadata(ccx, &loc.file.name, &loc.file.abs_path);
119+
let scope_metadata = unsafe {
93120
llvm::LLVMRustDIBuilderCreateLexicalBlock(
94121
DIB(ccx),
95-
parent_scope,
122+
parent_scope.scope_metadata,
96123
file_metadata,
97124
loc.line as c_uint,
98125
loc.col.to_usize() as c_uint)
99126
};
127+
scopes[scope] = MirDebugScope {
128+
scope_metadata: scope_metadata,
129+
file_start_pos: loc.file.start_pos,
130+
file_end_pos: loc.file.end_pos,
131+
};
100132
}

‎src/librustc_trans/debuginfo/metadata.rs

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ use context::SharedCrateContext;
2222
use session::Session;
2323

2424
use llvm::{self, ValueRef};
25-
use llvm::debuginfo::{DIType, DIFile, DIScope, DIDescriptor, DICompositeType};
25+
use llvm::debuginfo::{DIType, DIFile, DIScope, DIDescriptor, DICompositeType, DILexicalBlock};
2626

2727
use rustc::hir::def_id::DefId;
2828
use rustc::ty::subst::Substs;
@@ -1839,3 +1839,17 @@ pub fn create_global_var_metadata(cx: &CrateContext,
18391839
ptr::null_mut());
18401840
}
18411841
}
1842+
1843+
// Creates an "extension" of an existing DIScope into another file.
1844+
pub fn extend_scope_to_file(ccx: &CrateContext,
1845+
scope_metadata: DIScope,
1846+
file: &syntax_pos::FileMap)
1847+
-> DILexicalBlock {
1848+
let file_metadata = file_metadata(ccx, &file.name, &file.abs_path);
1849+
unsafe {
1850+
llvm::LLVMRustDIBuilderCreateLexicalBlockFile(
1851+
DIB(ccx),
1852+
scope_metadata,
1853+
file_metadata)
1854+
}
1855+
}

‎src/librustc_trans/debuginfo/mod.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,9 +53,10 @@ pub mod metadata;
5353
mod create_scope_map;
5454
mod source_loc;
5555

56-
pub use self::create_scope_map::create_mir_scopes;
56+
pub use self::create_scope_map::{create_mir_scopes, MirDebugScope};
5757
pub use self::source_loc::start_emitting_source_locations;
5858
pub use self::metadata::create_global_var_metadata;
59+
pub use self::metadata::extend_scope_to_file;
5960

6061
#[allow(non_upper_case_globals)]
6162
const DW_TAG_auto_variable: c_uint = 0x100;

‎src/librustc_trans/mir/mod.rs

Lines changed: 100 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -10,18 +10,17 @@
1010

1111
use libc::c_uint;
1212
use llvm::{self, ValueRef};
13-
use llvm::debuginfo::DIScope;
1413
use rustc::ty;
1514
use rustc::mir::repr as mir;
1615
use rustc::mir::tcx::LvalueTy;
1716
use session::config::FullDebugInfo;
1817
use base;
1918
use common::{self, Block, BlockAndBuilder, CrateContext, FunctionContext, C_null};
20-
use debuginfo::{self, declare_local, DebugLoc, VariableAccess, VariableKind};
19+
use debuginfo::{self, declare_local, DebugLoc, VariableAccess, VariableKind, FunctionDebugContext};
2120
use machine;
2221
use type_of;
2322

24-
use syntax_pos::DUMMY_SP;
23+
use syntax_pos::{DUMMY_SP, NO_EXPANSION, COMMAND_LINE_EXPN, BytePos};
2524
use syntax::parse::token::keywords;
2625

2726
use std::ops::Deref;
@@ -103,12 +102,67 @@ pub struct MirContext<'bcx, 'tcx:'bcx> {
103102
locals: IndexVec<mir::Local, LocalRef<'tcx>>,
104103

105104
/// Debug information for MIR scopes.
106-
scopes: IndexVec<mir::VisibilityScope, DIScope>
105+
scopes: IndexVec<mir::VisibilityScope, debuginfo::MirDebugScope>,
107106
}
108107

109108
impl<'blk, 'tcx> MirContext<'blk, 'tcx> {
110-
pub fn debug_loc(&self, source_info: mir::SourceInfo) -> DebugLoc {
111-
DebugLoc::ScopeAt(self.scopes[source_info.scope], source_info.span)
109+
pub fn debug_loc(&mut self, source_info: mir::SourceInfo) -> DebugLoc {
110+
// Bail out if debug info emission is not enabled.
111+
match self.fcx.debug_context {
112+
FunctionDebugContext::DebugInfoDisabled |
113+
FunctionDebugContext::FunctionWithoutDebugInfo => {
114+
// Can't return DebugLoc::None here because intrinsic::trans_intrinsic_call()
115+
// relies on debug location to obtain span of the call site.
116+
return DebugLoc::ScopeAt(self.scopes[source_info.scope].scope_metadata,
117+
source_info.span);
118+
}
119+
FunctionDebugContext::RegularContext(_) =>{}
120+
}
121+
122+
// In order to have a good line stepping behavior in debugger, we overwrite debug
123+
// locations of macro expansions with that of the outermost expansion site
124+
// (unless the crate is being compiled with `-Z debug-macros`).
125+
if source_info.span.expn_id == NO_EXPANSION ||
126+
source_info.span.expn_id == COMMAND_LINE_EXPN ||
127+
self.fcx.ccx.sess().opts.debugging_opts.debug_macros {
128+
129+
let scope_metadata = self.scope_metadata_for_loc(source_info.scope,
130+
source_info.span.lo);
131+
DebugLoc::ScopeAt(scope_metadata, source_info.span)
132+
} else {
133+
let cm = self.fcx.ccx.sess().codemap();
134+
// Walk up the macro expansion chain until we reach a non-expanded span.
135+
let mut span = source_info.span;
136+
while span.expn_id != NO_EXPANSION && span.expn_id != COMMAND_LINE_EXPN {
137+
if let Some(callsite_span) = cm.with_expn_info(span.expn_id,
138+
|ei| ei.map(|ei| ei.call_site.clone())) {
139+
span = callsite_span;
140+
} else {
141+
break;
142+
}
143+
}
144+
let scope_metadata = self.scope_metadata_for_loc(source_info.scope, span.lo);
145+
// Use span of the outermost call site, while keeping the original lexical scope
146+
DebugLoc::ScopeAt(scope_metadata, span)
147+
}
148+
}
149+
150+
// DILocations inherit source file name from the parent DIScope. Due to macro expansions
151+
// it may so happen that the current span belongs to a different file than the DIScope
152+
// corresponding to span's containing visibility scope. If so, we need to create a DIScope
153+
// "extension" into that file.
154+
fn scope_metadata_for_loc(&self, scope_id: mir::VisibilityScope, pos: BytePos)
155+
-> llvm::debuginfo::DIScope {
156+
let scope_metadata = self.scopes[scope_id].scope_metadata;
157+
if pos < self.scopes[scope_id].file_start_pos ||
158+
pos >= self.scopes[scope_id].file_end_pos {
159+
let cm = self.fcx.ccx.sess().codemap();
160+
debuginfo::extend_scope_to_file(self.fcx.ccx,
161+
scope_metadata,
162+
&cm.lookup_char_pos(pos).file)
163+
} else {
164+
scope_metadata
165+
}
112166
}
113167
}
114168

@@ -155,16 +209,38 @@ pub fn trans_mir<'blk, 'tcx: 'blk>(fcx: &'blk FunctionContext<'blk, 'tcx>) {
155209
analyze::cleanup_kinds(bcx, &mir))
156210
});
157211

212+
// Allocate a `Block` for every basic block
213+
let block_bcxs: IndexVec<mir::BasicBlock, Block<'blk,'tcx>> =
214+
mir.basic_blocks().indices().map(|bb| {
215+
if bb == mir::START_BLOCK {
216+
fcx.new_block("start")
217+
} else {
218+
fcx.new_block(&format!("{:?}", bb))
219+
}
220+
}).collect();
221+
158222
// Compute debuginfo scopes from MIR scopes.
159223
let scopes = debuginfo::create_mir_scopes(fcx);
160224

225+
let mut mircx = MirContext {
226+
mir: mir.clone(),
227+
fcx: fcx,
228+
llpersonalityslot: None,
229+
blocks: block_bcxs,
230+
unreachable_block: None,
231+
cleanup_kinds: cleanup_kinds,
232+
landing_pads: IndexVec::from_elem(None, mir.basic_blocks()),
233+
scopes: scopes,
234+
locals: IndexVec::new(),
235+
};
236+
161237
// Allocate variable and temp allocas
162-
let locals = {
163-
let args = arg_local_refs(&bcx, &mir, &scopes, &lvalue_locals);
238+
mircx.locals = {
239+
let args = arg_local_refs(&bcx, &mir, &mircx.scopes, &lvalue_locals);
164240
let vars = mir.var_decls.iter().enumerate().map(|(i, decl)| {
165241
let ty = bcx.monomorphize(&decl.ty);
166-
let scope = scopes[decl.source_info.scope];
167-
let dbg = !scope.is_null() && bcx.sess().opts.debuginfo == FullDebugInfo;
242+
let debug_scope = mircx.scopes[decl.source_info.scope];
243+
let dbg = debug_scope.is_valid() && bcx.sess().opts.debuginfo == FullDebugInfo;
168244

169245
let local = mir.local_index(&mir::Lvalue::Var(mir::Var::new(i))).unwrap();
170246
if !lvalue_locals.contains(local.index()) && !dbg {
@@ -173,11 +249,16 @@ pub fn trans_mir<'blk, 'tcx: 'blk>(fcx: &'blk FunctionContext<'blk, 'tcx>) {
173249

174250
let lvalue = LvalueRef::alloca(&bcx, ty, &decl.name.as_str());
175251
if dbg {
176-
bcx.with_block(|bcx| {
177-
declare_local(bcx, decl.name, ty, scope,
178-
VariableAccess::DirectVariable { alloca: lvalue.llval },
179-
VariableKind::LocalVariable, decl.source_info.span);
180-
});
252+
let dbg_loc = mircx.debug_loc(decl.source_info);
253+
if let DebugLoc::ScopeAt(scope, span) = dbg_loc {
254+
bcx.with_block(|bcx| {
255+
declare_local(bcx, decl.name, ty, scope,
256+
VariableAccess::DirectVariable { alloca: lvalue.llval },
257+
VariableKind::LocalVariable, span);
258+
});
259+
} else {
260+
panic!("Unexpected");
261+
}
181262
}
182263
LocalRef::Lvalue(lvalue)
183264
});
@@ -203,37 +284,15 @@ pub fn trans_mir<'blk, 'tcx: 'blk>(fcx: &'blk FunctionContext<'blk, 'tcx>) {
203284
})).collect()
204285
};
205286

206-
// Allocate a `Block` for every basic block
207-
let block_bcxs: IndexVec<mir::BasicBlock, Block<'blk,'tcx>> =
208-
mir.basic_blocks().indices().map(|bb| {
209-
if bb == mir::START_BLOCK {
210-
fcx.new_block("start")
211-
} else {
212-
fcx.new_block(&format!("{:?}", bb))
213-
}
214-
}).collect();
215-
216287
// Branch to the START block
217-
let start_bcx = block_bcxs[mir::START_BLOCK];
288+
let start_bcx = mircx.blocks[mir::START_BLOCK];
218289
bcx.br(start_bcx.llbb);
219290

220291
// Up until here, IR instructions for this function have explicitly not been annotated with
221292
// source code location, so we don't step into call setup code. From here on, source location
222293
// emitting should be enabled.
223294
debuginfo::start_emitting_source_locations(fcx);
224295

225-
let mut mircx = MirContext {
226-
mir: mir.clone(),
227-
fcx: fcx,
228-
llpersonalityslot: None,
229-
blocks: block_bcxs,
230-
unreachable_block: None,
231-
cleanup_kinds: cleanup_kinds,
232-
landing_pads: IndexVec::from_elem(None, mir.basic_blocks()),
233-
locals: locals,
234-
scopes: scopes
235-
};
236-
237296
let mut visited = BitVector::new(mir.basic_blocks().len());
238297

239298
let mut rpo = traversal::reverse_postorder(&mir);
@@ -271,7 +330,7 @@ pub fn trans_mir<'blk, 'tcx: 'blk>(fcx: &'blk FunctionContext<'blk, 'tcx>) {
271330
/// indirect.
272331
fn arg_local_refs<'bcx, 'tcx>(bcx: &BlockAndBuilder<'bcx, 'tcx>,
273332
mir: &mir::Mir<'tcx>,
274-
scopes: &IndexVec<mir::VisibilityScope, DIScope>,
333+
scopes: &IndexVec<mir::VisibilityScope, debuginfo::MirDebugScope>,
275334
lvalue_locals: &BitVector)
276335
-> Vec<LocalRef<'tcx>> {
277336
let fcx = bcx.fcx();
@@ -281,8 +340,8 @@ fn arg_local_refs<'bcx, 'tcx>(bcx: &BlockAndBuilder<'bcx, 'tcx>,
281340

282341
// Get the argument scope, if it exists and if we need it.
283342
let arg_scope = scopes[mir::ARGUMENT_VISIBILITY_SCOPE];
284-
let arg_scope = if !arg_scope.is_null() && bcx.sess().opts.debuginfo == FullDebugInfo {
285-
Some(arg_scope)
343+
let arg_scope = if arg_scope.is_valid() && bcx.sess().opts.debuginfo == FullDebugInfo {
344+
Some(arg_scope.scope_metadata)
286345
} else {
287346
None
288347
};

‎src/rustllvm/RustWrapper.cpp

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -521,6 +521,15 @@ extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
521521
));
522522
}
523523

524+
extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateLexicalBlockFile(
525+
LLVMRustDIBuilderRef Builder,
526+
LLVMRustMetadataRef Scope,
527+
LLVMRustMetadataRef File) {
528+
return wrap(Builder->createLexicalBlockFile(
529+
unwrapDI<DIDescriptor>(Scope),
530+
unwrapDI<DIFile>(File)));
531+
}
532+
524533
extern "C" LLVMRustMetadataRef LLVMRustDIBuilderCreateStaticVariable(
525534
LLVMRustDIBuilderRef Builder,
526535
LLVMRustMetadataRef Context,

‎src/test/debuginfo/auxiliary/macro-stepping.rs

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
// compile-flags:-g
12+
13+
#![crate_type = "rlib"]
14+
15+
#[macro_export]
16+
macro_rules! new_scope {
17+
() => {
18+
let x = 1;
19+
}
20+
}

‎src/test/debuginfo/lexical-scope-with-macro.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@
1010

1111
// min-lldb-version: 310
1212

13-
// compile-flags:-g
13+
// compile-flags:-g -Zdebug-macros
1414

1515
// === GDB TESTS ===================================================================================
1616

‎src/test/debuginfo/macro-stepping.rs

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
// ignore-windows
12+
// ignore-android
13+
// min-lldb-version: 310
14+
15+
// aux-build:macro-stepping.rs
16+
17+
#![allow(unused)]
18+
19+
#[macro_use]
20+
extern crate macro_stepping; // exports new_scope!()
21+
22+
// compile-flags:-g
23+
24+
// === GDB TESTS ===================================================================================
25+
26+
// gdb-command:run
27+
// gdb-command:next
28+
// gdb-command:frame
29+
// gdb-check:[...]#loc1[...]
30+
// gdb-command:next
31+
// gdb-command:frame
32+
// gdb-check:[...]#loc2[...]
33+
// gdb-command:next
34+
// gdb-command:frame
35+
// gdb-check:[...]#loc3[...]
36+
// gdb-command:next
37+
// gdb-command:frame
38+
// gdb-check:[...]#loc4[...]
39+
// gdb-command:next
40+
// gdb-command:frame
41+
// gdb-check:[...]#loc5[...]
42+
// gdb-command:next
43+
// gdb-command:frame
44+
// gdb-check:[...]#loc6[...]
45+
46+
// === LLDB TESTS ==================================================================================
47+
48+
// lldb-command:set set stop-line-count-before 0
49+
// lldb-command:set set stop-line-count-after 1
50+
// Can't set both to zero or lldb will stop printing source at all. So it will output the current
51+
// line and the next. We deal with this by having at least 2 lines between the #loc's
52+
53+
// lldb-command:run
54+
// lldb-command:next
55+
// lldb-command:frame select
56+
// lldb-check:[...]#loc1[...]
57+
// lldb-command:next
58+
// lldb-command:frame select
59+
// lldb-check:[...]#loc2[...]
60+
// lldb-command:next
61+
// lldb-command:frame select
62+
// lldb-check:[...]#loc3[...]
63+
// lldb-command:next
64+
// lldb-command:frame select
65+
// lldb-check:[...]#loc4[...]
66+
// lldb-command:next
67+
// lldb-command:frame select
68+
// lldb-check:[...]#loc5[...]
69+
70+
macro_rules! foo {
71+
() => {
72+
let a = 1;
73+
let b = 2;
74+
let c = 3;
75+
}
76+
}
77+
78+
macro_rules! foo2 {
79+
() => {
80+
foo!();
81+
let x = 1;
82+
foo!();
83+
}
84+
}
85+
86+
fn main() {
87+
zzz(); // #break
88+
89+
foo!(); // #loc1
90+
91+
foo2!(); // #loc2
92+
93+
let x = vec![42]; // #loc3
94+
95+
new_scope!(); // #loc4
96+
97+
println!("Hello {}", // #loc5
98+
"world");
99+
100+
zzz(); // #loc6
101+
}
102+
103+
fn zzz() {()}

0 commit comments

Comments
 (0)
Please sign in to comment.