Change:
Rust version: OS: Gentoo Linux AMD64
cc
The same thing happens with openssl-sys 0.4.1:
For anyone running into this, you can disable debug info to work around the issue until it's fixed:
Same problem here. Rust version: rustc 1.0.0-nightly ( 2015-02-17) (built 2015-02-18) Operating System: OS X Yosemite 10.10.2
It looks like I have the same problem: Compiling mio v0.2.1 () Running 1:1 error: internal compiler error: debuginfo: Could not find scope info for node NodeExpr(Expr { id: 5326, node: ExprStruct(Path { span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() }, global: false, segments: [PathSegment { identifier: StaticMutex, parameters: AngleBracketedParameters(AngleBracketedParameterData { lifetimes: [], types: [], bindings: [] }) }] }, [Field { ident: Spanned { node: lock, span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }, expr: Expr { id: 5327, node: ExprPath(Path { span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() }, global: false, segments: [PathSegment { identifier: sys, parameters: AngleBracketedParameters(AngleBracketedParameterData { lifetimes: [], types: [], bindings: [] }) }, PathSegment { identifier: MUTEXINIT, parameters: AngleBracketedParameters(AngleBracketedParameterData { lifetimes: [], types: [], bindings: [] }) }] }), span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }, span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }, Field { ident: Spanned { node: poison, span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }, expr: Expr { id: 5328, node: ExprPath(Path { span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() }, global: false, segments: [PathSegment { identifier: poison, parameters: AngleBracketedParameters(AngleBracketedParameterData { lifetimes: [], types: [], bindings: [] }) }, PathSegment { identifier: FLAGINIT, parameters: AngleBracketedParameters(AngleBracketedParameterData { lifetimes: [], types: [], bindings: [] }) }] }), span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }, span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }], None), span: Span { lo: BytePos(0), hi: BytePos(0), expnid: ExpnId() } }) #![allow(noncamelcasetypes, nonuppercaseglobals, nonsnakecase)] ^ Rust version: rustc 1.0.0-nightly ( 2015-02-17) (built 2015-02-18) OS: 3.13.0-24-generic -Ubuntu SMP Fri May 2 23:30:00 UTC 2014 x8664 x8664 x86_64 GNU/Linux
A minimized version:
Minimized a bit further actually, perhaps you could publish a version which uses instead of on the vector of ?
Er, nevermind, I have against rust-openssl to temporarily fix this.
I encountered a similar problem with constants in match patterns. This very probably has the same root cause, which is that the AST of constants gets substituted for the constant-reference during trans, but then we suddenly have a bunch of unrelated AST node ids in there. I'll try to fix this this week.
My minimal case:

Discussion:
&**expr } else { ccx.sess().span_bug(ref_expr.span, <del> &format!("get_const_val given non-constant item {}", </del> <ins> &format!("get_const_expr given non-constant item {}", </ins> item.repr(ccx.tcx()))); } }

fn_metadata: DISubprogram, argument_counter: Cell<uint>, source_locations_enabled: Cell<bool>, <ins> source_location_override: Cell<bool>, </ins> } enum VariableAccess<'a> {

return; } FunctionDebugContext::RegularContext(box ref function_debug_context) => { <ins> if function_debug_context.source_location_override.get() { // Just ignore any attempts to set a new debug location while // the override is active. return; } </ins> let cx = fcx.ccx; debug!("set_source_location: {}", cx.sess().codemap().span_to_string(span));

} } <ins> /// This function makes sure that all debug locations emitted while executing /// `wrapped_function` are set to the given `debug_loc`. pub fn with_source_location_override<F, R>(fcx: &FunctionContext, debug_loc: DebugLoc, wrapped_function: F) -> R where F: FnOnce() -> R { match fcx.debug_context { FunctionDebugContext::DebugInfoDisabled => { wrapped_function() } FunctionDebugContext::FunctionWithoutDebugInfo => { set_debug_location(fcx.ccx, UnknownLocation); wrapped_function() } FunctionDebugContext::RegularContext(box ref function_debug_context) => { if function_debug_context.source_location_override.get() { wrapped_function() } else { debug_loc.apply(fcx); function_debug_context.source_location_override.set(true); let result = wrapped_function(); function_debug_context.source_location_override.set(false); result } } } } </ins> /// Clears the current debug location. /// /// Instructions generated hereafter won't be assigned a source location.

fn_metadata: fn_metadata, argument_counter: Cell::new(1), source_locations_enabled: Cell::new(false), <ins> source_location_override: Cell::new(false), </ins> };

ast::ExprPath(..) => { match bcx.def(expr.id) { def::DefConst(did) => { <del> let expr = consts::get_const_expr(bcx.ccx(), did, expr); </del> <ins> let const_expr = consts::get_const_expr(bcx.ccx(), did, expr); </ins> // Temporarily get cleanup scopes out of the way, // as they require sub-expressions to be contained // inside the current AST scope.

// can't have destructors. let scopes = mem::replace(&mut *bcx.fcx.scopes.borrow_mut(), vec![]); <del> bcx = trans_into(bcx, expr, dest); </del> <ins> // Lock emitted debug locations to the location of // the constant reference expression. debuginfo::with_source_location_override(bcx.fcx, expr.debug_loc(), || { bcx = trans_into(bcx, const_expr, dest) }); </ins> let scopes = mem::replace(&mut *bcx.fcx.scopes.borrow_mut(), scopes); assert!(scopes.is_empty());

<ins> // Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // ignore-android: FIXME(#10381) // min-lldb-version: 310 // compile-flags:-g #![allow(unused_variables)] #![allow(dead_code)] #![omit_gdb_pretty_printer_section] // This test makes sure that the compiler doesn't crash when trying to assign // debug locations to const-expressions. use std::sync::MUTEX_INIT; use std::cell::UnsafeCell; const CONSTANT: u64 = 3 + 4; struct Struct { a: isize, b: usize, } const STRUCT: Struct = Struct { a: 1, b: 2 }; struct TupleStruct(u32); const TUPLE_STRUCT: TupleStruct = TupleStruct(4); enum Enum { Variant1(char), Variant2 { a: u8 }, Variant3 } const VARIANT1: Enum = Enum::Variant1('v'); const VARIANT2: Enum = Enum::Variant2 { a: 2 }; const VARIANT3: Enum = Enum::Variant3; const STRING: &'static str = "String"; const VEC: [u32; 8] = [0; 8]; const NESTED: (Struct, TupleStruct) = (STRUCT, TUPLE_STRUCT); const UNSAFE_CELL: UnsafeCell<bool> = UnsafeCell { value: false }; fn main() { let mut _constant = CONSTANT; let mut _struct = STRUCT; let mut _tuple_struct = TUPLE_STRUCT; let mut _variant1 = VARIANT1; let mut _variant2 = VARIANT2; let mut _variant3 = VARIANT3; let mut _string = STRING; let mut _vec = VEC; let mut _nested = NESTED; let mut _extern = MUTEX_INIT; let mut _unsafe_cell = UNSAFE_CELL; } </ins>

<ins> // Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // min-lldb-version: 310 // compile-flags:-g // === GDB TESTS =================================================================================== // gdb-command:run // gdb-command:print s // gdb-check:$1 = [...]"abcd" // gdb-command:print len // gdb-check:$2 = 20 // gdb-command:print local0 // gdb-check:$3 = 19 // gdb-command:print local1 // gdb-check:$4 = true // gdb-command:print local2 // gdb-check:$5 = 20.5 // gdb-command:continue // === LLDB TESTS ================================================================================== // lldb-command:run // lldb-command:print len // lldb-check:[...]$0 = 20 // lldb-command:print local0 // lldb-check:[...]$1 = 19 // lldb-command:print local1 // lldb-check:[...]$2 = true // lldb-command:print local2 // lldb-check:[...]$3 = 20.5 // lldb-command:continue #![allow(unused_variables)] #![allow(dead_code)] #![omit_gdb_pretty_printer_section] #[no_mangle] pub unsafe extern "C" fn fn_with_c_abi(s: *const u8, len: i32) -> i32 { let local0 = len - 1; let local1 = len > 2; let local2 = (len as f64) + 0.5; zzz(); // #break return 0; } fn main() { unsafe { fn_with_c_abi(b"abcd0".as_ptr(), 20); } } #[inline(never)] fn zzz() {()} </ins>