Document type_length_limit.

src/attributes.md

@@ -227,6 +227,7 @@ The following is an index of all built-in attributes.
 - Limits
   - [`recursion_limit`] — Sets the maximum recursion limit for certain
     compile-time operations.
+  - [`type_length_limit`] — Sets the maximum size of a polymorphic type.
 - Runtime
   - [`panic_handler`] — Sets the function to handle panics.
   - [`global_allocator`] — Sets the global memory allocator.
@@ -283,6 +284,7 @@ The following is an index of all built-in attributes.
 [`repr`]: type-layout.html#representations
 [`should_panic`]: attributes/testing.html#the-should_panic-attribute
 [`test`]: attributes/testing.html#the-test-attribute
+[`type_length_limit`]: attributes/limits.html#the-type_length_limit-attribute
 [`used`]: abi.html#the-used-attribute
 [`warn`]: attributes/diagnostics.html#lint-check-attributes
 [`windows_subsystem`]: runtime.html#the-windows_subsystem-attribute

src/attributes/limits.md

@@ -4,11 +4,55 @@ The following [attributes] affect compile-time limits.
 
 ## The `recursion_limit` attribute
 
-The *`recursion_limit` attribute* may be applied at the crate level to set the
+The *`recursion_limit` attribute* may be applied at the [crate] level to set the
 maximum depth for potentially infinitely-recursive compile-time operations
-like auto-dereference or macro expansion. It uses the [_MetaNameValueStr_]
-syntax to specify the recursion depth. The default is
-`#![recursion_limit="64"]`.
+like macro expansion or auto-dereference. It uses the [_MetaNameValueStr_]
+syntax to specify the recursion depth.
+
+> Note: The default in `rustc` is 64.
+
+```rust,compile_fail
+#![recursion_limit = "4"]
+
+macro_rules! a {
+    () => { a!(1) };
+    (1) => { a!(2) };
+    (2) => { a!(3) };
+    (3) => { a!(4) };
+    (4) => { };
+}
+
+// This fails to expand because it requires a recursion depth greater than 4.
+a!{}
+```
+
+```rust,compile_fail
+#![recursion_limit = "1"]
+
+// This fails because it requires two recursive steps to auto-derefence.
+(|_: &u8| {})(&&1);
+```
+
+## The `type_length_limit` attribute
+
+The *`type_length_limit` attribute* limits the maximum number of type
+substitutions made when constructing a concrete type during monomorphization.
+It is applied at the [crate] level, and uses the [_MetaNameValueStr_] syntax
+to set the limit based on the number of type substitutions.
+
+> Note: The default in `rustc` is 1048576.
+
+```rust,compile_fail
+#![type_length_limit = "8"]
+
+fn f<T>(x: T) {}
+
+// This fails to compile because monomorphizing to
+// `f::<(i32, i32, i32, i32, i32, i32, i32, i32, i32)>>` requires more
+// than 8 type elements.
+f(((1, 2, 3, 4, 5, 6, 7, 8, 9));
+```
 
-[attributes]: attributes.html
 [_MetaNameValueStr_]: attributes.html#meta-item-attribute-syntax
+[attributes]: attributes.html
+[crate]: crates-and-source-files.html