16      * This is wrong from the semantics point of view, since it is an ordered
81 runtime which implements these new semantics.
247 ARC's semantics and restrictions.
273     varied transfer semantics.
288 Retain count semantics
309 :arc-term:`high-level semantics` is an intentionally vague term; the intent is
322 semantics to a computation history in which these sends are removed.  Note that
333 When the semantics call for performing one of these operations on a retainable
336 All of the semantics described in this document are subject to additional
339 semantics describe the high-level behaviors that the compiler implements, not
461 statically resolves has different retain semantics on its result from the
463 function call is made through a static type with different retain semantics on
502 autorelease pool.  There are no additional semantics enforced in the definition
563 .. _arc.objects.restrictions.conversion.with.known.semantics:
565 Conversion to retainable object pointer type of expressions with known semantics
778   copy semantics on the setter.
821 semantics, and the value in the ivar will not be automatically released during
824 .. _arc.ownership.semantics:
826 Semantics  section in Ownership qualification
831 semantics for each of these operations.  It is still undefined behavior to
834 A load or store with "primitive semantics" has the same semantics as the
844 * For all other objects, the lvalue is loaded with primitive semantics.
847 semantics vary based on the qualification:
850   lvalue is loaded with primitive semantics; third, the new pointee is stored
851   into the lvalue with primitive semantics; and finally, the old pointee is
860   lvalue using primitive semantics.
862   and stored into the lvalue using primitive semantics.
867 #. First, a null pointer is stored into the lvalue using primitive semantics.
870    then assigned into the object using the usual assignment semantics.
881 to loading the lvalue with primitive semantics, writing a null pointer to it
882 with primitive semantics, and then releasing the result of the load at the end
898 assignment semantics with a pointer to an Objective-C object whose class does
966   ``const __unsafe_unretained`` is permitted because the semantics of reads are
967   equivalent across all these ownership semantics, and that's a very useful and
1045    primitive semantics.
1048    semantics, and that value is assigned into ``*p``.
1084   Unlike in C, we can express all the necessary ARC semantics for
1249   possible to define low-level ownership semantics with attributes like
1254 .. _arc.family.semantics:
1256 Semantics of method families
1259 A method's membership in a method family may imply non-standard semantics for
1276 .. _arc.family.semantics.init:
1278 Semantics of ``init``
1292 is mutable in an ``init`` method and has the usual semantics for a ``__strong``
1302 .. _arc.family.semantics.result_type:
1417   :ref:`precise lifetime semantics <arc.optimization.precise>`, or
1420   imprecise lifetime semantics and, at some point after ``T`` but
1518 Precise lifetime semantics
1524 semantics`.
1527 lifetime semantics.  Such objects are simply strong references which hold
1533   Applying these precise-lifetime semantics strictly would be prohibitive.
1539 it should be considered to be an object with precise lifetime semantics.
1546   requesting these semantics will not be burdensome, and may even make the code
1574   ``retainCount`` is banned because ARC robs it of consistent semantics.  The
1602   semantics of ARC; many tricks which worked tolerably under manual reference
1605   for example in a category; the implementations must obey the :ref:`semantics
1684 semantics.
1711 <arc.family.semantics.init>`.  Further, ``self`` is **always** implicitly
1751 literal expression have the same ownership semantics as the local variables
1757 ``__block`` variables, which is a shift in semantics from non-ARC, where
1764 parameter variable or reading a ``__weak`` variable, whenever these semantics
1851 from a ``__strong`` object with :ref:`precise lifetime semantics
1858   Tying this to precise lifetime semantics is ideal, as for local variables
1908 transfer semantics cannot be accurately captured using any of these