Next: Modula-2, Previous: Pascal, Up: Supported Languages

#### 15.4.8 Rust

gdb supports the Rust Programming Language. Type- and value-printing, and expression parsing, are reasonably complete. However, there are a few peculiarities and holes to be aware of.

- Linespecs (see Specify Location) are never relative to the current crate. Instead, they act as if there were a global namespace of crates, somewhat similar to the way `extern crate` behaves.

  That is, if gdb is stopped at a breakpoint in a function in crate ``A`', module ``B`', then `break B::f` will attempt to set a breakpoint in a function named ``f`' in a crate named ``B`'.

  As a consequence of this approach, linespecs also cannot refer to items using ``self::`' or ``super::`'.

- Because gdb implements Rust name-lookup semantics in expressions, it will sometimes prepend the current crate to a name. For example, if gdb is stopped at a breakpoint in the crate ``K`', then `print ::x::y` will try to find the symbol ``K::x::y`'.

  However, since it is useful to be able to refer to other crates when debugging, gdb provides the `extern` extension to circumvent this. To use the extension, just put `extern` before a path expression to refer to the otherwise unavailable “global” scope.

  In the above example, if you wanted to refer to the symbol ``y`' in the crate ``x`', you would use `print extern x::y`.

- The Rust expression evaluator does not support “statement-like” expressions such as `if` or `match`, or lambda expressions.
- Tuple expressions are not implemented.
- The Rust expression evaluator does not currently implement the `Drop` trait. Objects that may be created by the evaluator will never be destroyed.
- gdb does not implement type inference for generics. In order to call generic functions or otherwise refer to generic items, you will have to specify the type parameters manually.
- gdb currently uses the C`++` demangler for Rust. In most cases this does not cause any problems. However, in an expression context, completing a generic function name will give syntactically invalid results. This happens because Rust requires the ``::`' operator between the function name and its generic arguments. For example, gdb might provide a completion like `crate::f<u32>`, where the parser would require `crate::f::<u32>`.
- As of this writing, the Rust compiler (version 1.8) has a few holes in the debugging information it generates. These holes prevent certain features from being implemented by gdb:
  - Method calls cannot be made via traits.
  - Operator overloading is not implemented.
  - When debugging in a monomorphized function, you cannot use the generic type names.
  - The type `Self` is not available.
  - `use` statements are not available, so some names may not be available in the crate.