1 // Legend: 2 // `N` - number of combination, from 0 to 4*4*4=64 3 // `Outer < Invoc` means that expansion that produced macro definition `Outer` 4 // is a strict ancestor of expansion that produced macro definition `Inner`. 5 // `>`, `=` and `Unordered` mean "strict descendant", "same" and 6 // "not in ordering relation" for parent expansions. 7 // `+` - possible configuration 8 // `-` - configuration impossible due to properties of partial ordering 9 // `-?` - configuration impossible due to block/scope syntax 10 // `+?` - configuration possible only with legacy scoping 11 12 // N | Outer ~ Invoc | Invoc ~ Inner | Outer ~ Inner | Possible | 13 // 1 | < | < | < | + | 14 // 2 | < | < | = | - | 15 // 3 | < | < | > | - | 16 // 4 | < | < | Unordered | - | 17 // 5 | < | = | < | + | 18 // 6 | < | = | = | - | 19 // 7 | < | = | > | - | 20 // 8 | < | = | Unordered | - | 21 // 9 | < | > | < | + | 22 // 10 | < | > | = | + | 23 // 11 | < | > | > | -? | 24 // 12 | < | > | Unordered | -? | 25 // 13 | < | Unordered | < | + | 26 // 14 | < | Unordered | = | - | 27 // 15 | < | Unordered | > | - | 28 // 16 | < | Unordered | Unordered | -? | 29 // 17 | = | < | < | + | 30 // 18 | = | < | = | - | 31 // 19 | = | < | > | - | 32 // 20 | = | < | Unordered | - | 33 // 21 | = | = | < | - | 34 // 22 | = | = | = | + | 35 // 23 | = | = | > | - | 36 // 24 | = | = | Unordered | - | 37 // 25 | = | > | < | - | 38 // 26 | = | > | = | - | 39 // 27 | = | > | > | -? | 40 // 28 | = | > | Unordered | - | 41 // 29 | = | Unordered | < | - | 42 // 30 | = | Unordered | = | - | 43 // 31 | = | Unordered | > | - | 44 // 32 | = | Unordered | Unordered | -? | 45 // 33 | > | < | < | +? | 46 // 34 | > | < | = | +? | 47 // 35 | > | < | > | +? | 48 // 36 | > | < | Unordered | + | 49 // 37 | > | = | < | - | 50 // 38 | > | = | = | - | 51 // 39 | > | = | > | + | 52 // 40 | > | = | Unordered | - | 53 // 41 | > | > | < | - | 54 // 42 | > | > | = | - | 55 // 43 | > | > | > | -? | 56 // 44 | > | > | Unordered | - | 57 // 45 | > | Unordered | < | - | 58 // 46 | > | Unordered | = | - | 59 // 47 | > | Unordered | > | -? | 60 // 48 | > | Unordered | Unordered | -? | 61 // 49 | Unordered | < | < | -? | 62 // 50 | Unordered | < | = | - | 63 // 51 | Unordered | < | > | - | 64 // 52 | Unordered | < | Unordered | + | 65 // 53 | Unordered | = | < | - | 66 // 54 | Unordered | = | = | - | 67 // 55 | Unordered | = | > | - | 68 // 56 | Unordered | = | Unordered | + | 69 // 57 | Unordered | > | < | - | 70 // 58 | Unordered | > | = | - | 71 // 59 | Unordered | > | > | + | 72 // 60 | Unordered | > | Unordered | + | 73 // 61 | Unordered | Unordered | < | +? | 74 // 62 | Unordered | Unordered | = | +? | 75 // 63 | Unordered | Unordered | > | +? | 76 // 64 | Unordered | Unordered | Unordered | + | 77 78 #![feature(decl_macro, rustc_attrs)] 79 80 struct Right; 81 // struct Wrong; // not defined 82 83 macro_rules! include { () => { 84 macro_rules! gen_outer { () => { 85 macro_rules! m { () => { Wrong } } 86 }} 87 macro_rules! gen_inner { () => { 88 macro_rules! m { () => { Right } } 89 }} 90 macro_rules! gen_invoc { () => { 91 m!() 92 }} 93 94 // ----------------------------------------------------------- 95 96 fn check1() { 97 macro_rules! m { () => {} } 98 99 macro_rules! gen_gen_inner_invoc { () => { 100 gen_inner!(); 101 m!(); //~ ERROR `m` is ambiguous 102 }} 103 gen_gen_inner_invoc!(); 104 } 105 106 fn check5() { 107 macro_rules! m { () => { Wrong } } 108 109 macro_rules! gen_inner_invoc { () => { 110 macro_rules! m { () => { Right } } 111 m!(); // OK 112 }} 113 gen_inner_invoc!(); 114 } 115 116 fn check9() { 117 macro_rules! m { () => { Wrong } } 118 119 macro_rules! gen_inner_gen_invoc { () => { 120 macro_rules! m { () => { Right } } 121 gen_invoc!(); // OK 122 }} 123 gen_inner_gen_invoc!(); 124 } 125 126 fn check10() { 127 macro_rules! m { () => { Wrong } } 128 129 macro_rules! m { () => { Right } } 130 131 gen_invoc!(); // OK 132 } 133 134 fn check13() { 135 macro_rules! m { () => {} } 136 137 gen_inner!(); 138 139 macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous 140 gen_invoc!(); 141 } 142 143 fn check17() { 144 macro_rules! m { () => {} } 145 146 gen_inner!(); 147 148 m!(); //~ ERROR `m` is ambiguous 149 } 150 151 fn check22() { 152 macro_rules! m { () => { Wrong } } 153 154 macro_rules! m { () => { Right } } 155 156 m!(); // OK 157 } 158 159 fn check36() { 160 gen_outer!(); 161 162 gen_inner!(); 163 164 m!(); //~ ERROR `m` is ambiguous 165 } 166 167 fn check39() { 168 gen_outer!(); 169 170 macro_rules! m { () => { Right } } 171 172 m!(); // OK 173 } 174 175 fn check52() { 176 gen_outer!(); 177 178 macro_rules! gen_gen_inner_invoc { () => { 179 gen_inner!(); 180 m!(); //~ ERROR `m` is ambiguous 181 }} 182 gen_gen_inner_invoc!(); 183 } 184 185 fn check56() { 186 gen_outer!(); 187 188 macro_rules! gen_inner_invoc { () => { 189 macro_rules! m { () => { Right } } 190 m!(); // OK 191 }} 192 gen_inner_invoc!(); 193 } 194 195 fn check59() { 196 gen_outer!(); 197 198 macro_rules! m { () => { Right } } 199 200 gen_invoc!(); // OK 201 } 202 203 fn check60() { 204 gen_outer!(); 205 206 macro_rules! gen_inner_gen_invoc { () => { 207 macro_rules! m { () => { Right } } 208 gen_invoc!(); // OK 209 }} 210 gen_inner_gen_invoc!(); 211 } 212 213 fn check64() { 214 gen_outer!(); 215 216 gen_inner!(); 217 218 macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous 219 gen_invoc!(); 220 } 221 222 // ----------------------------------------------------------- 223 // These configurations are only possible with legacy macro scoping 224 225 fn check33() { 226 macro_rules! gen_outer_gen_inner { () => { 227 macro_rules! m { () => {} } 228 gen_inner!(); 229 }} 230 gen_outer_gen_inner!(); 231 232 m!(); //~ ERROR `m` is ambiguous 233 } 234 235 fn check34() { 236 macro_rules! gen_outer_inner { () => { 237 macro_rules! m { () => { Wrong } } 238 macro_rules! m { () => { Right } } 239 }} 240 gen_outer_inner!(); 241 242 m!(); // OK 243 } 244 245 fn check35() { 246 macro_rules! gen_gen_outer_inner { () => { 247 gen_outer!(); 248 macro_rules! m { () => { Right } } 249 }} 250 gen_gen_outer_inner!(); 251 252 m!(); // OK 253 } 254 255 fn check61() { 256 macro_rules! gen_outer_gen_inner { () => { 257 macro_rules! m { () => {} } 258 gen_inner!(); 259 }} 260 gen_outer_gen_inner!(); 261 262 macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous 263 gen_invoc!(); 264 } 265 266 fn check62() { 267 macro_rules! gen_outer_inner { () => { 268 macro_rules! m { () => { Wrong } } 269 macro_rules! m { () => { Right } } 270 }} 271 gen_outer_inner!(); 272 273 gen_invoc!(); // OK 274 } 275 276 fn check63() { 277 macro_rules! gen_gen_outer_inner { () => { 278 gen_outer!(); 279 macro_rules! m { () => { Right } } 280 }} 281 gen_gen_outer_inner!(); 282 283 gen_invoc!(); // OK 284 } 285 }} 286 287 include!(); 288 main()289fn main() {} 290