src/test/debuginfo/unreachable-locals.rs

   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.
   4 //
   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.
  10
  11 // min-lldb-version: 310
  12
  13 // compile-flags:-g
  14
  15 #![allow(unused_variables)]
  16 #![omit_gdb_pretty_printer_section]
  17
  18 // No need to actually run the debugger, just make sure that the compiler can
  19 // handle locals in unreachable code.
  20
  21 fn after_return() {
  22     return;
  23     let x = "0";
  24     let (ref y,z) = (1i32, 2u32);
  25     match (20i32, 'c') {
  26         (a, ref b) => {}
  27     }
  28     for a in &[111i32] {}
  29     let test = if some_predicate() { 1 } else { 2 };
  30     while some_predicate() {
  31         let abc = !some_predicate();
  32     }
  33     loop {
  34         let abc = !some_predicate();
  35         break;
  36     }
  37     // nested block
  38     {
  39         let abc = !some_predicate();
  40
  41         {
  42             let def = !some_predicate();
  43         }
  44     }
  45 }
  46
  47 fn after_panic() {
  48     panic!();
  49     let x = "0";
  50     let (ref y,z) = (1i32, 2u32);
  51     match (20i32, 'c') {
  52         (a, ref b) => {}
  53     }
  54     for a in &[111i32] {}
  55     let test = if some_predicate() { 1 } else { 2 };
  56     while some_predicate() {
  57         let abc = !some_predicate();
  58     }
  59     loop {
  60         let abc = !some_predicate();
  61         break;
  62     }
  63     // nested block
  64     {
  65         let abc = !some_predicate();
  66
  67         {
  68             let def = !some_predicate();
  69         }
  70     }
  71 }
  72
  73 fn after_diverging_function() {
  74     diverge();
  75     let x = "0";
  76     let (ref y,z) = (1i32, 2u32);
  77     match (20i32, 'c') {
  78         (a, ref b) => {}
  79     }
  80     for a in &[111i32] {}
  81     let test = if some_predicate() { 1 } else { 2 };
  82     while some_predicate() {
  83         let abc = !some_predicate();
  84     }
  85     loop {
  86         let abc = !some_predicate();
  87         break;
  88     }
  89     // nested block
  90     {
  91         let abc = !some_predicate();
  92
  93         {
  94             let def = !some_predicate();
  95         }
  96     }
  97 }
  98
  99 fn after_break() {
 100     loop {
 101         break;
 102         let x = "0";
 103         let (ref y,z) = (1i32, 2u32);
 104         match (20i32, 'c') {
 105             (a, ref b) => {}
 106         }
 107         for a in &[111i32] {}
 108         let test = if some_predicate() { 1 } else { 2 };
 109         while some_predicate() {
 110             let abc = !some_predicate();
 111         }
 112         loop {
 113             let abc = !some_predicate();
 114             break;
 115         }
 116         // nested block
 117         {
 118             let abc = !some_predicate();
 119
 120             {
 121                 let def = !some_predicate();
 122             }
 123         }
 124     }
 125 }
 126
 127 fn after_continue() {
 128     for _ in 0..10i32 {
 129         continue;
 130         let x = "0";
 131         let (ref y,z) = (1i32, 2u32);
 132         match (20i32, 'c') {
 133             (a, ref b) => {}
 134         }
 135         for a in &[111i32] {}
 136         let test = if some_predicate() { 1 } else { 2 };
 137         while some_predicate() {
 138             let abc = !some_predicate();
 139         }
 140         loop {
 141             let abc = !some_predicate();
 142             break;
 143         }
 144         // nested block
 145         {
 146             let abc = !some_predicate();
 147
 148             {
 149                 let def = !some_predicate();
 150             }
 151         }
 152     }
 153 }
 154
 155 fn main() {
 156     after_return();
 157     after_panic();
 158     after_diverging_function();
 159     after_break();
 160     after_continue();
 161 }
 162
 163 fn diverge() -> ! {
 164     panic!();
 165 }
 166
 167 fn some_predicate() -> bool { true || false }
 168