add tests for $crate in QSelf paths

Author: ExpHP

src/test/run-pass-fulldeps/proc-macro/auxiliary/double.rs

@@ -16,6 +16,8 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 
+// Outputs another copy of the struct.  Useful for testing the tokens
+// seen by the proc_macro.
 #[proc_macro_derive(Double)]
 pub fn derive(input: TokenStream) -> TokenStream {
     format!("mod foo {{ {} }}", input.to_string()).parse().unwrap()

src/test/run-pass-fulldeps/proc-macro/auxiliary/external-crate-var.rs

@@ -0,0 +1,51 @@
+// Copyright 2016 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub struct ExternFoo;
+
+pub trait ExternTrait {
+    const CONST: u32;
+    type Assoc;
+}
+
+impl ExternTrait for ExternFoo {
+    const CONST: u32 = 0;
+    type Assoc = ExternFoo;
+}
+
+#[macro_export]
+macro_rules! external { () => {
+    mod bar {
+        #[derive(Double)]
+        struct Bar($crate::ExternFoo);
+    }
+
+    mod qself {
+        #[derive(Double)]
+        struct QSelf(<$crate::ExternFoo as $crate::ExternTrait>::Assoc);
+    }
+
+    mod qself_recurse {
+        #[derive(Double)]
+        struct QSelfRecurse(<
+            <$crate::ExternFoo as $crate::ExternTrait>::Assoc
+            as $crate::ExternTrait>::Assoc
+        );
+    }
+
+    mod qself_in_const {
+        #[derive(Double)]
+        #[repr(u32)]
+        enum QSelfInConst {
+            Variant = <$crate::ExternFoo as $crate::ExternTrait>::CONST,
+        }
+    }
+} }
+

src/test/run-pass-fulldeps/proc-macro/crate-var.rs

@@ -9,19 +9,63 @@
 // except according to those terms.
 
 // aux-build:double.rs
+// aux-build:external-crate-var.rs
 // ignore-stage1
 
 #![allow(unused)]
 
 #[macro_use]
 extern crate double;
+#[macro_use]
+extern crate external_crate_var;
 
 struct Foo;
 
-macro_rules! m { () => {
-    #[derive(Double)]
-    struct Bar($crate::Foo);
+trait Trait {
+    const CONST: u32;
+    type Assoc;
+}
+
+impl Trait for Foo {
+    const CONST: u32 = 0;
+    type Assoc = Foo;
+}
+
+macro_rules! local { () => {
+    // derive_Double outputs secondary copies of each definition
+    // to test what the proc_macro sees.
+    mod bar {
+        #[derive(Double)]
+        struct Bar($crate::Foo);
+    }
+
+    mod qself {
+        #[derive(Double)]
+        struct QSelf(<::Foo as $crate::Trait>::Assoc);
+    }
+
+    mod qself_recurse {
+        #[derive(Double)]
+        struct QSelfRecurse(<<$crate::Foo as $crate::Trait>::Assoc as $crate::Trait>::Assoc);
+    }
+
+    mod qself_in_const {
+        #[derive(Double)]
+        #[repr(u32)]
+        enum QSelfInConst {
+            Variant = <::Foo as $crate::Trait>::CONST,
+        }
+    }
 } }
-m!();
+
+mod local {
+    local!();
+}
+
+// and now repeat the above tests, using a macro defined in another crate
+
+mod external {
+    external!{}
+}
 
 fn main() {}