From 4f92f452bd701fb39156d66d4756cc48cc396a8a Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Mon, 16 Sep 2013 23:05:47 +1000 Subject: [PATCH] Tests for fixed issues. Closes #2074. Closes #5008. Closes #7519. Closes #7673. Closes #7770. Closes #8171. --- ...e-5008-borrowed-traitobject-method-call.rs | 43 ++++++++++++++++ .../run-pass/issue-7519-match-unit-in-arg.rs | 19 +++++++ ...7673-cast-generically-implemented-trait.rs | 30 ++++++++++++ ...fault-method-self-inherit-builtin-trait.rs | 25 ++++++++++ src/test/run-pass/nested-enum-same-names.rs | 49 +++++++++++++++++++ 5 files changed, 166 insertions(+) create mode 100644 src/test/run-pass/issue-5008-borrowed-traitobject-method-call.rs create mode 100644 src/test/run-pass/issue-7519-match-unit-in-arg.rs create mode 100644 src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs create mode 100644 src/test/run-pass/issue-8171-default-method-self-inherit-builtin-trait.rs create mode 100644 src/test/run-pass/nested-enum-same-names.rs diff --git a/src/test/run-pass/issue-5008-borrowed-traitobject-method-call.rs b/src/test/run-pass/issue-5008-borrowed-traitobject-method-call.rs new file mode 100644 index 0000000000000..ce9bb725a1b1b --- /dev/null +++ b/src/test/run-pass/issue-5008-borrowed-traitobject-method-call.rs @@ -0,0 +1,43 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/* + +#5008 cast to &Trait causes code to segfault on method call + +It fixes itself if the &Trait is changed to @Trait. +*/ + +trait Debuggable { + fn debug_name(&self) -> ~str; +} + +#[deriving(Clone)] +struct Thing { +name: ~str, +} + +impl Thing { + fn new() -> Thing { Thing { name: ~"dummy" } } +} + +impl Debuggable for Thing { + fn debug_name(&self) -> ~str { self.name.clone() } +} + +fn print_name(x: &Debuggable) +{ + println(fmt!("debug_name = %s", x.debug_name())); +} + +fn main() { + let thing = Thing::new(); + print_name(&thing as &Debuggable); +} diff --git a/src/test/run-pass/issue-7519-match-unit-in-arg.rs b/src/test/run-pass/issue-7519-match-unit-in-arg.rs new file mode 100644 index 0000000000000..ba84dd44b2f0a --- /dev/null +++ b/src/test/run-pass/issue-7519-match-unit-in-arg.rs @@ -0,0 +1,19 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/* +#7519 ICE pattern matching unit in function argument +*/ + +fn foo(():()) { } + +fn main() { + foo(()); +} diff --git a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs new file mode 100644 index 0000000000000..1492b5895bae5 --- /dev/null +++ b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs @@ -0,0 +1,30 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// xfail-pretty #9253 pretty printer doesn't preserve the bounds on trait objects + +/* + +#7673 Polymorphically creating traits barely works + +*/ + +fn main() {} + +trait A {} +impl A for T {} + +fn owned1(a: T) { ~a as ~A:; } /* note `:` */ +fn owned2(a: ~T) { a as ~A:; } +fn owned3(a: ~T) { ~a as ~A:; } + +fn managed1(a: T) { @a as @A; } +fn managed2(a: @T) { a as @A; } +fn managed3(a: @T) { @a as @A; } diff --git a/src/test/run-pass/issue-8171-default-method-self-inherit-builtin-trait.rs b/src/test/run-pass/issue-8171-default-method-self-inherit-builtin-trait.rs new file mode 100644 index 0000000000000..be68d50c9615d --- /dev/null +++ b/src/test/run-pass/issue-8171-default-method-self-inherit-builtin-trait.rs @@ -0,0 +1,25 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/* + +#8171 Self is not recognised as implementing kinds in default method implementations + +*/ + +fn require_send(_: T){} + +trait TragicallySelfIsNotSend: Send { + fn x(self) { + require_send(self); + } +} + +fn main(){} diff --git a/src/test/run-pass/nested-enum-same-names.rs b/src/test/run-pass/nested-enum-same-names.rs new file mode 100644 index 0000000000000..7d9b744ab0f31 --- /dev/null +++ b/src/test/run-pass/nested-enum-same-names.rs @@ -0,0 +1,49 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/* + +#7770 ICE with sibling methods containing same-name-enum containing + same-name-member + +If you have two methods in an impl block, each containing an enum +(with the same name), each containing at least one value with the same +name, rustc gives the same LLVM symbol for the two of them and fails, +as it does not include the method name in the symbol name. + +*/ + +pub struct Foo; +impl Foo { + pub fn foo() { + enum Panic { Common }; + } + pub fn bar() { + enum Panic { Common }; + } +} + +/* +#2074 duplicate symbols with enum in boxed closure +*/ + +fn foo() { + let one: @fn() -> uint = || { + enum r { a } + a as uint + }; + let two: @fn() -> uint = || { + enum r { a } + a as uint + }; + one(); two(); +} + +fn main() {}