Improve proc_macro crate type docs

Author: Havvy

src/linkage.md

@@ -60,12 +60,13 @@ be ignored in favor of only building the artifacts specified by command line.
 * `--crate-type=proc-macro`, `#[crate_type = "proc-macro"]` - The output
   produced is not specified, but if a `-L` path is provided to it then the
   compiler will recognize the output artifacts as a macro and it can be loaded
-  for a program. If a crate is compiled with the `proc-macro` crate type it
-  will forbid exporting any items in the crate other than those functions
-  tagged `#[proc_macro_derive]` and those functions must also be placed at the
-  crate root. Finally, the compiler will automatically set the
-  `cfg(proc_macro)` annotation whenever any crate type of a compilation is the
-  `proc-macro` crate type.
+  for a program. Crates compiled with this crate type  must only export
+  [procedural macros]. The compiler will automatically set the `proc_macro`
+  [configuration option]. The crates are always compiled with the same target
+  that the compiler itself was built with. For example, if you are executing
+  the compiler from Linux with an `x86_64` CPU, the target will be
+  `x86_64-unknown-linux-gnu` even if the crate is a dependency of another crate
+  being built for a different target.
 
 Note that these outputs are stackable in the sense that if multiple are
 specified, then the compiler will produce each form of output at once without

src/procedural-macros.md

@@ -24,22 +24,6 @@ Procedural macros must be defined in a crate with the [crate type] of
 > proc-macro = true
 > ```
 
-Procedural macros are always compiled with the same target as the compiler
-itself. For example if you execute `cargo build --target
-arm-unknown-linux-gnueabi` then procedural macros will not be compiled for ARM,
-but rather your build computer (for example `x86_64-unknown-linux-gnu`).
-
-Procedural macro crates are not currently allowed to export any items except
-procedural macros (we'll see how to define these in a bit). For example this
-crate is not allowed:
-
-```rust
-pub fn foo() {}
-```
-
-because the `foo` function is not a procedural macro. Procedural macros are
-loaded dynamically by the compiler when they are needed during compilation.
-
 ### The `proc_macro` crate
 
 Procedural macro crates almost always will link to the compiler-provided