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

@@ -7,8 +7,42 @@ The following [attributes] affect compile-time limits.
 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"]`.
+syntax to specify the recursion depth. The default is 64.
+
+```rust,ignore
+#![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!{}
+```
+
+## The `type_length_limit` attribute
+
+The *`type_length_limit` attribute* limits the maximum size of a type
+constructed 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 within the type. The default value is 1048576.
+
+```rust,ignore
+#![type_length_limit = "8"]
+
+type A = (B, B, B);
+type B = (C, C, C);
+struct C;
+
+// This fails to compile because monomorphizing
+// `drop::<Option<((C, C, C), (C, C, C), (C, C, C))>>` requires more than 8
+// type elements.
+drop::<Option<A>>(None);
+```
 
 [attributes]: attributes.html
 [_MetaNameValueStr_]: attributes.html#meta-item-attribute-syntax