mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-28 04:25:10 +08:00
12df5c002d
I learned recently that empty struct expressions, like "X{}", have been
promoted from experimental to stable in Rust. This patch changes the
Rust expression parser to allow this case.
New test case included.
Built and regtested on x86-64 Fedora 23, using Rust 1.11 beta.
2016-07-21 Tom Tromey <tom@tromey.com>
* rust-lang.c (rust_tuple_struct_type_p): Return false for empty
structs.
* rust-exp.y (struct_expr_list): Allow empty elements.
2016-07-21 Tom Tromey <tom@tromey.com>
* gdb.rust/simple.rs (main): Use empty struct expression.
* gdb.rust/simple.exp: Add tests for empty struct expression.
124 lines
2.8 KiB
Rust
124 lines
2.8 KiB
Rust
// Copyright (C) 2016 Free Software Foundation, Inc.
|
|
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#![allow(dead_code)]
|
|
#![allow(unused_variables)]
|
|
#![allow(unused_assignments)]
|
|
|
|
|
|
pub struct HiBob {
|
|
pub field1: i32,
|
|
field2: u64,
|
|
}
|
|
|
|
struct ByeBob(i32, u64);
|
|
|
|
enum Something {
|
|
One,
|
|
Two,
|
|
Three
|
|
}
|
|
|
|
enum MoreComplicated {
|
|
One,
|
|
Two(i32),
|
|
Three(HiBob),
|
|
Four{this: bool, is: u8, a: char, struct_: u64, variant: u32},
|
|
}
|
|
|
|
// tests the nonzero optimization, but fields are reversed
|
|
enum NonZeroOptimized {
|
|
Empty,
|
|
Value(String),
|
|
}
|
|
|
|
fn diff2(x: i32, y: i32) -> i32 {
|
|
x - y
|
|
}
|
|
|
|
// Empty function, should not have "void"
|
|
// or "()" in its return type
|
|
fn empty() {
|
|
|
|
}
|
|
|
|
pub struct Unit;
|
|
|
|
// This triggers the non-zero optimization that yields a different
|
|
// enum representation in the debug info.
|
|
enum SpaceSaver {
|
|
Thebox(u8, Box<i32>),
|
|
Nothing,
|
|
}
|
|
|
|
fn main () {
|
|
let a = ();
|
|
let b : [i32; 0] = [];
|
|
|
|
let mut c = 27;
|
|
let d = c = 99;
|
|
|
|
let e = MoreComplicated::Two(73);
|
|
let e2 = MoreComplicated::Four {this: true, is: 8, a: 'm',
|
|
struct_: 100, variant: 10};
|
|
|
|
let f = "hi bob";
|
|
let g = b"hi bob";
|
|
let h = b'9';
|
|
|
|
let i = ["whatever"; 8];
|
|
|
|
let j = Unit;
|
|
let j2 = Unit{};
|
|
|
|
let k = SpaceSaver::Nothing;
|
|
let l = SpaceSaver::Thebox(9, Box::new(1729));
|
|
|
|
let v = Something::Three;
|
|
let w = [1,2,3,4];
|
|
let w_ptr = &w[0];
|
|
let x = (23, 25.5);
|
|
let y = HiBob {field1: 7, field2: 8};
|
|
let z = ByeBob(7, 8);
|
|
|
|
let slice = &w[2..3];
|
|
let fromslice = slice[0];
|
|
let slice2 = &slice[0..1];
|
|
|
|
let all1 = &w[..];
|
|
let all2 = &slice[..];
|
|
|
|
let from1 = &w[1..];
|
|
let from2 = &slice[1..];
|
|
|
|
let to1 = &w[..3];
|
|
let to2 = &slice[..1];
|
|
|
|
// tests for enum optimizations
|
|
|
|
let str_some = Some("hi".to_string());
|
|
let str_none = None::<String>;
|
|
let box_some = Some(Box::new(1u8));
|
|
let box_none = None::<Box<u8>>;
|
|
let int_some = Some(1u8);
|
|
let int_none = None::<u8>;
|
|
let custom_some = NonZeroOptimized::Value("hi".into());
|
|
let custom_none = NonZeroOptimized::Empty;
|
|
|
|
println!("{}, {}", x.0, x.1); // set breakpoint here
|
|
println!("{}", diff2(92, 45));
|
|
empty();
|
|
}
|