The documentation is right, but doesn't cover the motivation.
The @_eagerMove attribute means the compiler will destroy variables of that type immediately after their last use, even if that means a weak reference or unsafe pointer gets invalidated:
func takeArray(_ refs: consuming [Ref]) { ... }
let arrayOfRefs = [Ref()]
weak var weakRef = arrayOfRefs[0]
takeArray(arrayOfRefs) // destroyed at last use
print(weakRef!) // crash
Destroying a variable consumes its value ("eagerConsume" would have been a better name). If the value contained any references, this decrements their reference counts.
@_eagerMove is applied to copy-on-write data types: Array, Set, Dictionary, and String.
The main reason for this is practical: failing to optimize away unnecessary instances of a CoW value has dramatic performance implications in which all the collection's elements are unexpectedly copied. In real-world situations, it's almost never possible for the compiler to tell whether weak references or unsafe pointers exist, so relying on conservative analysis is ineffective and unpredictable. Futhermore, we would like to optimize away creation of these containers if they are never used.
The language justification for performing this optimization in important cases is that, formally, Swift and Objective-C (with ARC) have always allowed references to be destroyed after their last use.
The usability rationale for this is that CoW data types have value semantics in Swift. They don't have programer-visible deinitializers. And, in general, programers can't predict when the storage will be freed. It is, of course, possible that the elements of the CoW data type themselves to have deinitializers. And, as shown above, weak references to the elements may exist. This places some burden on programers who want to use a CoW data type to keep its elements alive, without actually requiring the elements to be accessed via the CoW container (a fairly bizarre situation). To do so, the lifetime of the CoW container would need to be explicitly tied to a scope:
func takeArray(_ refs: consuming [Ref]) { ... }
let arrayOfRefs = [Ref()]
weak var weakRef = arrayOfRefs[0]
defer { withExtendedLifetime(arrayOfRefs) {} }
takeArray(arrayOfRefs) // copy the array by incrementing its storage refcount
print(weakRef!) // correct