asyncio doc: add "asyncio-" prefix to references

Doc/library/asyncio-dev.rst

@@ -43,7 +43,7 @@ blocks for 1 second, other tasks are delayed by 1 second which can have an
 important impact on reactivity.
 
 For networking and subprocesses, the :mod:`asyncio` module provides high-level
-APIs like :ref:`protocols <protocol>`.
+APIs like :ref:`protocols <asyncio-protocol>`.
 
 An executor can be used to run a task in a different thread or even in a
 different process, to not block the thread of the event loop. See the

Doc/library/asyncio-eventloop.rst

 .. currentmodule:: asyncio
 
-.. _event-loop:
+.. _asyncio-event-loop:
 
 Event loops
 ===========
@@ -10,10 +10,10 @@ It provides multiple facilities, amongst which:
 
 * Registering, executing and cancelling delayed calls (timeouts)
 
-* Creating client and server :ref:`transports <transport>` for various
+* Creating client and server :ref:`transports <asyncio-transport>` for various
   kinds of communication
 
-* Launching subprocesses and the associated :ref:`transports <transport>`
+* Launching subprocesses and the associated :ref:`transports <asyncio-transport>`
   for communication with an external program
 
 * Delegating costly function calls to a pool of threads
@@ -172,7 +172,7 @@ Creating connections
 
    Create a streaming transport connection to a given Internet *host* and
    *port*.  *protocol_factory* must be a callable returning a
-   :ref:`protocol <protocol>` instance.
+   :ref:`protocol <asyncio-protocol>` instance.
 
    This method returns a :ref:`coroutine object <coroutine>` which will try to
    establish the connection in the background.  When successful, the
@@ -180,11 +180,11 @@ Creating connections
 
    The chronological synopsis of the underlying operation is as follows:
 
-   #. The connection is established, and a :ref:`transport <transport>`
+   #. The connection is established, and a :ref:`transport <asyncio-transport>`
       is created to represent it.
 
    #. *protocol_factory* is called without arguments and must return a
-      :ref:`protocol <protocol>` instance.
+      :ref:`protocol <asyncio-protocol>` instance.
 
    #. The protocol instance is tied to the transport, and its
       :meth:`connection_made` method is called.

Doc/library/asyncio-protocol.rst

@@ -4,7 +4,7 @@
 Transports  and protocols (low-level API)
 +++++++++++++++++++++++++++++++++++++++++
 
-.. _transport:
+.. _asyncio-transport:
 
 Transports
 ==========
@@ -16,7 +16,7 @@ which will create the transport and try to initiate the underlying
 communication channel, calling you back when it succeeds.
 
 Once the communication channel is established, a transport is always
-paired with a :ref:`protocol <protocol>` instance.  The protocol can
+paired with a :ref:`protocol <asyncio-protocol>` instance.  The protocol can
 then call the transport's methods for various purposes.
 
 :mod:`asyncio` currently implements transports for TCP, UDP, SSL, and
@@ -228,14 +228,14 @@ BaseSubprocessTransport
       stop the subprocess.
 
 
-.. _protocol:
+.. _asyncio-protocol:
 
 Protocols
 =========
 
 :mod:`asyncio` provides base classes that you can subclass to implement
 your network protocols.  Those classes are used in conjunction with
-:ref:`transports <transport>` (see below): the protocol parses incoming
+:ref:`transports <asyncio-transport>` (see below): the protocol parses incoming
 data and asks for the writing of outgoing data, while the transport is
 responsible for the actual I/O and buffering.
 
@@ -410,7 +410,7 @@ Coroutines can be scheduled in a protocol method using :func:`async`, but there
 is not guarantee on the execution order. Protocols are not aware of coroutines
 created in protocol methods and so will not wait for them.
 
-To have a reliable execution order, use :ref:`stream objects <streams>` in a
+To have a reliable execution order, use :ref:`stream objects <asyncio-streams>` in a
 coroutine with ``yield from``. For example, the :meth:`StreamWriter.drain`
 coroutine can be used to wait until the write buffer is flushed.
 

Doc/library/asyncio-stream.rst

 .. currentmodule:: asyncio
 
-.. _streams:
+.. _asyncio-streams:
 
 ++++++++++++++++++++++++
 Streams (high-level API)

Doc/library/asyncio.rst

@@ -15,10 +15,10 @@ code using coroutines, multiplexing I/O access over sockets and other
 resources, running network clients and servers, and other related primitives.
 Here is a more detailed list of the package contents:
 
-* a pluggable :ref:`event loop <event-loop>` with various system-specific
+* a pluggable :ref:`event loop <asyncio-event-loop>` with various system-specific
   implementations;
 
-* :ref:`transport <transport>` and :ref:`protocol <protocol>` abstractions
+* :ref:`transport <asyncio-transport>` and :ref:`protocol <asyncio-protocol>` abstractions
   (similar to those in `Twisted <http://twistedmatrix.com/>`_);
 
 * concrete support for TCP, UDP, SSL, subprocess pipes, delayed calls, and
@@ -32,7 +32,7 @@ Here is a more detailed list of the package contents:
 
 * cancellation support for Futures and coroutines;
 
-* :ref:`synchronization primitives <sync>` for use between coroutines in
+* :ref:`synchronization primitives <asyncio-sync>` for use between coroutines in
   a single thread, mimicking those in the :mod:`threading` module;
 
 * an interface for passing work off to a threadpool, for times when