diff --git a/src/corelib/doc/src/animation.qdoc b/src/corelib/doc/src/animation.qdoc
index 5839d42a3999f8589a09b1b2d8b3cde22b93901c..9385c0899526358b716f2c94c3a87fd9789781db 100644
--- a/src/corelib/doc/src/animation.qdoc
+++ b/src/corelib/doc/src/animation.qdoc
@@ -48,7 +48,7 @@
 
     The animation framework aims to provide an easy way for creating animated
     and smooth GUIs. By animating Qt properties, the framework provides great
-    freedom for animating widgets and other \l{QObject}s. The framework can
+    freedom for animating widgets and other {QObject}s. The framework can
     also be used with the Graphics View framework. Many of the concepts
     available in the animation framework are also available in \l{Qt Quick},
     where it offers a declarative way of defining animations. Much of the
@@ -57,7 +57,7 @@
 
     In this overview, we explain the basics of its architecture. We
     also show examples of the most common techniques that the
-    framework allows for animating QObjects and graphics items.
+    framework allows for animating {QObject}s and graphics items.
 
     \tableofcontents
 
@@ -85,7 +85,7 @@
     over the property using an easing curve. So when you want to
     animate a value, you can declare it as a property and make your
     class a QObject. Note that this gives us great freedom in
-    animating already existing widgets and other \l{QObject}s.
+    animating already existing widgets and other {QObject}s.
 
     Complex animations can be constructed by building a tree structure
     of \l{QAbstractAnimation}s. The tree is built by using
diff --git a/src/corelib/doc/src/containers.qdoc b/src/corelib/doc/src/containers.qdoc
index 6017269272b5920cd36b7f88e054f0ef14ba6638..a517ca32d394928e7e473e08059319340b97f23e 100644
--- a/src/corelib/doc/src/containers.qdoc
+++ b/src/corelib/doc/src/containers.qdoc
@@ -386,7 +386,7 @@
     \l{QMapIterator::hasPrevious()}{hasPrevious()},
     \l{QMapIterator::previous()}{previous()}, and
     \l{QMapIterator::peekPrevious()}{peekPrevious()}. The key and
-    value components are extracted by calling key() and value() on
+    value components are extracted by calling \l{QMapIterator::key()}{key()} and \l{QMapIterator::value()}{value()} on
     the object returned by next(), peekNext(), previous(), or
     peekPrevious().
 
@@ -395,7 +395,7 @@
 
     \snippet code/doc_src_containers.cpp 7
 
-    QMapIterator also provides a key() and a value() function that
+    QMapIterator also provides a \l{QMapIterator::key()}{key()} and a \l{QMapIterator::value()}{value()} function that
     operate directly on the iterator and that return the key and
     value of the last item that the iterator jumped above. For
     example, the following code copies the contents of a QMap into a
@@ -459,13 +459,13 @@
     \snippet code/doc_src_containers.cpp 10
 
     Unlike \l{Java-style iterators}, STL-style iterators point
-    directly at items. The begin() function of a container returns an
+    directly at items. The \l{QList::begin()}{begin()} function of a container returns an
     iterator that points to the first item in the container. The
-    end() function of a container returns an iterator to the
+    \l{QList::end()}{end()} function of a container returns an iterator to the
     imaginary item one position past the last item in the container.
-    end() marks an invalid position; it must never be dereferenced.
+    \l {QList::end()}{end()} marks an invalid position; it must never be dereferenced.
     It is typically used in a loop's break condition. If the list is
-    empty, begin() equals end(), so we never execute the loop.
+    empty, \l{QList::begin}{begin()} equals \l{QList:end()}{end()}, so we never execute the loop.
 
     The diagram below shows the valid iterator positions as red
     arrows for a vector containing four items:
@@ -484,8 +484,8 @@
     compilers also allow us to write \c{i->toLower()}, but some
     don't.
 
-    For read-only access, you can use const_iterator, constBegin(),
-    and constEnd(). For example:
+    For read-only access, you can use const_iterator, \l{QList::constBegin}{constBegin()},
+    and \l{QList::constEnd()}{constEnd()}. For example:
 
     \snippet code/doc_src_containers.cpp 12
 
@@ -759,7 +759,7 @@
     QString.
 
     QVector<T> also uses that algorithm for data types that can be
-    moved around in memory using memcpy() (including the basic C++
+    moved around in memory using \c memcpy() (including the basic C++
     types, the pointer types, and Qt's \l{shared classes}) but uses a
     different algorithm for data types that can only be moved by
     calling the copy constructor and a destructor. Since the cost of
@@ -790,7 +790,7 @@
     \endlist
 
     If you know approximately how many items you will store in a
-    container, you can start by calling reserve(), and when you are
-    done populating the container, you can call squeeze() to release
+    container, you can start by calling \l{QString::reserve()}{reserve()}, and when you are
+    done populating the container, you can call \l{QString::squeeze()}{squeeze()} to release
     the extra preallocated memory.
 */
diff --git a/src/corelib/doc/src/datastreamformat.qdoc b/src/corelib/doc/src/datastreamformat.qdoc
index b6efe6aa336d305c1b167b6452aebc888c08f9ee..56a6d0aafa65e3aa0e2d540e2c879cfe0374a380 100644
--- a/src/corelib/doc/src/datastreamformat.qdoc
+++ b/src/corelib/doc/src/datastreamformat.qdoc
@@ -173,7 +173,7 @@
             \li If the image is null a "null image" marker is saved;
             otherwise the image is saved in PNG or BMP format (depending
             on the stream version). If you want control of the format,
-            stream the image into a QBuffer (using QImageIO) and stream
+            stream the image into a QBuffer (using QImageIOHandler/QImageIOPlugin) and stream
             that.
             \endlist
     \row \li QKeySequence
diff --git a/src/corelib/doc/src/filestorage.qdoc b/src/corelib/doc/src/filestorage.qdoc
index 394d920923018968c9beb3745b21633a15167b86..a60c5846ffd749d781f767776dba854eab6e25ff 100644
--- a/src/corelib/doc/src/filestorage.qdoc
+++ b/src/corelib/doc/src/filestorage.qdoc
@@ -86,8 +86,8 @@ read console input and write console output.
 There are three general ways to use QTextStream when reading text files:
 
 \list
-    \li Chunk by chunk, by calling readLine() or readAll().
-    \li Word by word. QTextStream supports streaming into QStrings, QByteArrays
+    \li Chunk by chunk, by calling \l{QBuffer::readLine()}{readLine()} or \l{QBuffer::readAll()}{readAll()}.
+    \li Word by word. QTextStream supports streaming into {QString}s, {QByteArray}s
         and char* buffers. Words are delimited by space, and leading white space
         is automatically skipped.
     \li Character by character, by streaming into QChar or char types. This
diff --git a/src/corelib/doc/src/objectmodel/signalsandslots.qdoc b/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
index f79e8a7dca729e4dce914075ba95903fdd240e2a..b9b1874d0f5ae0fabac16090100e94e49a984a1a 100644
--- a/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
+++ b/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
@@ -242,7 +242,7 @@
 
     By default, for every connection you make, a signal is emitted;
     two signals are emitted for duplicate connections. You can break
-    all of these connections with a single disconnect() call.
+    all of these connections with a single \l{QObject::disconnect()}{disconnect()} call.
     If you pass the Qt::UniqueConnection \a type, the connection will only
     be made if it is not a duplicate. If there is already a duplicate
     (exact same signal to the exact same slot on the same objects),
@@ -251,9 +251,7 @@
     This example illustrates that objects can work together without needing to
     know any information about each other. To enable this, the objects only
     need to be connected together, and this can be achieved with some simple
-    QObject::connect() function calls, or with \c{uic}'s
-    \l{Using a Designer UI File in Your Application#Automatic Connections}
-    {automatic connections} feature.
+    QObject::connect() function calls, or with \c{uic}'s {automatic connections} feature.
 
 
     \section1 A Real Example
@@ -354,7 +352,7 @@
     connect(sender, &QObject::destroyed, this, &MyObject::objectDestroyed);
     \endcode
 
-    There are several advantages to using connect() with function pointers.
+    There are several advantages to using QObject::connect() with function pointers.
     First, it allows the compiler to check that the signal's arguments are
     compatible with the slot's arguments. Arguments can also be implicitly
     converted by the compiler, if needed.
@@ -407,7 +405,7 @@
     will open: "Tax File", "Accounts File", or "Report File".
 
     In order to open the correct file, you use QSignalMapper::setMapping() to
-    map all the clicked() signals to a QSignalMapper object. Then you connect
+    map all the QPushButton::clicked() signals to a QSignalMapper object. Then you connect
     the file's QPushButton::clicked() signal to the QSignalMapper::map() slot.
 
     \snippet signalmapper/filereader.cpp 0