src/test/incremental/hashes/extern_mods.rs

   1 // This test case tests the incremental compilation hash (ICH) implementation
   2 // for `extern` modules.
   3
   4 // The general pattern followed here is: Change one thing between rev1 and rev2
   5 // and make sure that the hash has changed, then change nothing between rev2 and
   6 // rev3 and make sure that the hash has not changed.
   7
   8 // build-pass (FIXME(62277): could be check-pass?)
   9 // revisions: cfail1 cfail2 cfail3
  10 // compile-flags: -Z query-dep-graph -Zincremental-ignore-spans
  11
  12 #![allow(warnings)]
  13 #![feature(rustc_attrs)]
  14 #![feature(unboxed_closures)]
  15 #![feature(link_args)]
  16 #![crate_type="rlib"]
  17
  18
  19 // Change function name --------------------------------------------------------
  20 #[cfg(cfail1)]
  21 extern {
  22     pub fn change_function_name1(c: i64) -> i32;
  23 }
  24
  25 #[cfg(not(cfail1))]
  26 #[rustc_dirty(cfg="cfail2")]
  27 #[rustc_clean(cfg="cfail3")]
  28 extern {
  29     pub fn change_function_name2(c: i64) -> i32;
  30 }
  31
  32
  33
  34 // Change parameter name -------------------------------------------------------
  35 #[cfg(cfail1)]
  36 extern {
  37     pub fn change_parameter_name(c: i64) -> i32;
  38 }
  39
  40 #[cfg(not(cfail1))]
  41 #[rustc_dirty(cfg="cfail2")]
  42 #[rustc_clean(cfg="cfail3")]
  43 extern {
  44     pub fn change_parameter_name(d: i64) -> i32;
  45 }
  46
  47
  48
  49 // Change parameter type -------------------------------------------------------
  50 #[cfg(cfail1)]
  51 extern {
  52     pub fn change_parameter_type(c: i64) -> i32;
  53 }
  54
  55 #[cfg(not(cfail1))]
  56 #[rustc_dirty(cfg="cfail2")]
  57 #[rustc_clean(cfg="cfail3")]
  58 extern {
  59     pub fn change_parameter_type(c: i32) -> i32;
  60 }
  61
  62
  63
  64 // Change return type ----------------------------------------------------------
  65 #[cfg(cfail1)]
  66 extern {
  67     pub fn change_return_type(c: i32) -> i32;
  68 }
  69
  70 #[cfg(not(cfail1))]
  71 #[rustc_dirty(cfg="cfail2")]
  72 #[rustc_clean(cfg="cfail3")]
  73 extern {
  74     pub fn change_return_type(c: i32) -> i8;
  75 }
  76
  77
  78
  79 // Add parameter ---------------------------------------------------------------
  80 #[cfg(cfail1)]
  81 extern {
  82     pub fn add_parameter(c: i32) -> i32;
  83 }
  84
  85 #[cfg(not(cfail1))]
  86 #[rustc_dirty(cfg="cfail2")]
  87 #[rustc_clean(cfg="cfail3")]
  88 extern {
  89     pub fn add_parameter(c: i32, d: i32) -> i32;
  90 }
  91
  92
  93
  94 // Add return type -------------------------------------------------------------
  95 #[cfg(cfail1)]
  96 extern {
  97     pub fn add_return_type(c: i32);
  98 }
  99
 100 #[cfg(not(cfail1))]
 101 #[rustc_dirty(cfg="cfail2")]
 102 #[rustc_clean(cfg="cfail3")]
 103 extern {
 104     pub fn add_return_type(c: i32) -> i32;
 105 }
 106
 107
 108
 109 // Make function variadic ------------------------------------------------------
 110 #[cfg(cfail1)]
 111 extern {
 112     pub fn make_function_variadic(c: i32);
 113 }
 114
 115 #[cfg(not(cfail1))]
 116 #[rustc_dirty(cfg="cfail2")]
 117 #[rustc_clean(cfg="cfail3")]
 118 extern {
 119     pub fn make_function_variadic(c: i32, ...);
 120 }
 121
 122
 123
 124 // Change calling convention ---------------------------------------------------
 125 #[cfg(cfail1)]
 126 extern "C" {
 127     pub fn change_calling_convention(c: i32);
 128 }
 129
 130 #[cfg(not(cfail1))]
 131 #[rustc_dirty(cfg="cfail2")]
 132 #[rustc_clean(cfg="cfail3")]
 133 extern "rust-call" {
 134     pub fn change_calling_convention(c: i32);
 135 }
 136
 137
 138
 139 // Make function public --------------------------------------------------------
 140 #[cfg(cfail1)]
 141 extern {
 142     fn make_function_public(c: i32);
 143 }
 144
 145 #[cfg(not(cfail1))]
 146 #[rustc_dirty(cfg="cfail2")]
 147 #[rustc_clean(cfg="cfail3")]
 148 extern {
 149     pub fn make_function_public(c: i32);
 150 }
 151
 152
 153
 154 // Add function ----------------------------------------------------------------
 155 #[cfg(cfail1)]
 156 extern {
 157     pub fn add_function1(c: i32);
 158 }
 159
 160 #[cfg(not(cfail1))]
 161 #[rustc_dirty(cfg="cfail2")]
 162 #[rustc_clean(cfg="cfail3")]
 163 extern {
 164     pub fn add_function1(c: i32);
 165     pub fn add_function2();
 166 }
 167
 168
 169
 170 // Change link-args ------------------------------------------------------------
 171 #[cfg(cfail1)]
 172 #[link_args = "-foo -bar"]
 173 extern {
 174     pub fn change_link_args(c: i32);
 175 }
 176
 177 #[cfg(not(cfail1))]
 178 #[rustc_dirty(cfg="cfail2")]
 179 #[rustc_clean(cfg="cfail3")]
 180 #[link_args = "-foo -bar -baz"]
 181 extern {
 182     pub fn change_link_args(c: i32);
 183 }
 184
 185
 186
 187 // Change link-name ------------------------------------------------------------
 188 #[cfg(cfail1)]
 189 #[link(name = "foo")]
 190 extern {
 191     pub fn change_link_name(c: i32);
 192 }
 193
 194 #[cfg(not(cfail1))]
 195 #[rustc_dirty(cfg="cfail2")]
 196 #[rustc_clean(cfg="cfail3")]
 197 #[link(name = "bar")]
 198 extern {
 199     pub fn change_link_name(c: i32);
 200 }
 201
 202 type c_i32 = i32;
 203 type c_i64 = i64;
 204
 205 // Indirectly change parameter type --------------------------------------------
 206 mod indirectly_change_parameter_type {
 207     #[cfg(cfail1)]
 208     use super::c_i32 as c_int;
 209     #[cfg(not(cfail1))]
 210     use super::c_i64 as c_int;
 211
 212     #[rustc_dirty(cfg="cfail2")]
 213     #[rustc_clean(cfg="cfail3")]
 214     extern {
 215         pub fn indirectly_change_parameter_type(c: c_int);
 216     }
 217 }
 218
 219
 220
 221 // Indirectly change return type --------------------------------------------
 222 mod indirectly_change_return_type {
 223     #[cfg(cfail1)]
 224     use super::c_i32 as c_int;
 225     #[cfg(not(cfail1))]
 226     use super::c_i64 as c_int;
 227
 228     #[rustc_dirty(cfg="cfail2")]
 229     #[rustc_clean(cfg="cfail3")]
 230     extern {
 231         pub fn indirectly_change_return_type() -> c_int;
 232     }
 233 }