1 // Copyright 2013-2014 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.
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.
11 // ignore-android: FIXME(#10381)
13 #![feature(managed_boxes)]
16 // debugger:set print pretty off
17 // debugger:rbreak zzz
21 // debugger:print stack_unique.value
23 // debugger:print stack_unique.next.val->value
26 // debugger:print unique_unique->value
28 // debugger:print unique_unique->next.val->value
31 // debugger:print box_unique->val.value
33 // debugger:print box_unique->val.next.val->value
36 // debugger:print vec_unique[0].value
38 // debugger:print vec_unique[0].next.val->value
41 // debugger:print borrowed_unique->value
43 // debugger:print borrowed_unique->next.val->value
47 // debugger:print stack_managed.value
49 // debugger:print stack_managed.next.val->val.value
52 // debugger:print unique_managed->value
54 // debugger:print unique_managed->next.val->val.value
57 // debugger:print box_managed->val.value
59 // debugger:print box_managed->val.next.val->val.value
62 // debugger:print vec_managed[0].value
64 // debugger:print vec_managed[0].next.val->val.value
67 // debugger:print borrowed_managed->value
69 // debugger:print borrowed_managed->next.val->val.value
73 // debugger:print long_cycle1.value
75 // debugger:print long_cycle1.next->value
77 // debugger:print long_cycle1.next->next->value
79 // debugger:print long_cycle1.next->next->next->value
82 // debugger:print long_cycle2.value
84 // debugger:print long_cycle2.next->value
86 // debugger:print long_cycle2.next->next->value
89 // debugger:print long_cycle3.value
91 // debugger:print long_cycle3.next->value
94 // debugger:print long_cycle4.value
97 // debugger:print (*****long_cycle_w_anonymous_types).value
100 // debugger:print (*****((*****long_cycle_w_anonymous_types).next.val)).value
105 #![allow(unused_variable)]
106 #![feature(struct_variant)]
113 struct UniqueNode<T> {
114 next: Opt<~UniqueNode<T>>,
118 struct ManagedNode<T> {
119 next: Opt<@ManagedNode<T>>,
123 struct LongCycle1<T> {
124 next: ~LongCycle2<T>,
128 struct LongCycle2<T> {
129 next: ~LongCycle3<T>,
133 struct LongCycle3<T> {
134 next: ~LongCycle4<T>,
138 struct LongCycle4<T> {
139 next: Option<~LongCycle1<T>>,
143 struct LongCycleWithAnonymousTypes {
144 next: Opt<~~~~~LongCycleWithAnonymousTypes>,
148 // This test case makes sure that recursive structs are properly described. The Node structs are
149 // generic so that we can have a new type (that newly needs to be described) for the different
150 // cases. The potential problem with recursive types is that the DI generation algorithm gets
151 // trapped in an endless loop. To make sure, we actually test this in the different cases, we have
152 // to operate on a new type each time, otherwise we would just hit the DI cache for all but the
155 // The different cases below (stack_*, unique_*, box_*, etc) are set up so that the type description
156 // algorithm will enter the type reference cycle that is created by a recursive definition from a
157 // different context each time.
159 // The "long cycle" cases are constructed to span a longer, indirect recursion cycle between types.
160 // The different locals will cause the DI algorithm to enter the type reference cycle at different
164 let stack_unique: UniqueNode<u16> = UniqueNode {
174 let unique_unique: ~UniqueNode<u32> = ~UniqueNode {
184 let box_unique: @UniqueNode<u64> = @UniqueNode {
194 let vec_unique: [UniqueNode<f32>, ..1] = [UniqueNode {
204 let borrowed_unique: &UniqueNode<f64> = &UniqueNode {
214 let stack_managed: ManagedNode<u16> = ManagedNode {
224 let unique_managed: ~ManagedNode<u32> = ~ManagedNode {
234 let box_managed: @ManagedNode<u64> = @ManagedNode {
244 let vec_managed: [ManagedNode<f32>, ..1] = [ManagedNode {
254 let borrowed_managed: &ManagedNode<f64> = &ManagedNode {
265 let long_cycle1: LongCycle1<u16> = LongCycle1 {
279 let long_cycle2: LongCycle2<u32> = LongCycle2 {
290 let long_cycle3: LongCycle3<u64> = LongCycle3 {
298 let long_cycle4: LongCycle4<f32> = LongCycle4 {
303 // It's important that LongCycleWithAnonymousTypes is encountered only at the end of the
305 let long_cycle_w_anonymous_types = ~~~~~LongCycleWithAnonymousTypes {
307 val: ~~~~~LongCycleWithAnonymousTypes {