4 files changed, 89 insertions, 24 deletions
diff --git a/src/qml/doc/src/cppintegration/definetypes.qdoc b/src/qml/doc/src/cppintegration/definetypes.qdoc
index 2fdd6edded..aeff2b5776 100644
--- a/src/qml/doc/src/cppintegration/definetypes.qdoc
+++ b/src/qml/doc/src/cppintegration/definetypes.qdoc
@@ -70,6 +70,21 @@ exposed to QML but the type itself should not be instantiable.
 For a quick guide to choosing the correct approach to expose C++ types to QML,
 see \l {Choosing the Correct Integration Method Between C++ and QML}.
 
+\section2 Preconditions
+
+All the macros mentioned below are available from the \c qqml.h
+header. You need to add the following code to the files using them in order to
+make the macros available:
+
+\code
+#include <QtQml/qqml.h>
+\endcode
+
+Furthermore, your class declarations have to live in headers reachable via your
+project's include path. The declarations are used to generate registration code
+at compile time, and the registration code needs to include the headers that
+contain the declarations.
+
 \section2 Registering an Instantiable Object Type
 
 \b{Any QObject-derived C++ class can be registered as the definition of a
diff --git a/src/qml/doc/src/qmlfunctions.qdoc b/src/qml/doc/src/qmlfunctions.qdoc
index f48a5f475b..92d9bdec49 100644
--- a/src/qml/doc/src/qmlfunctions.qdoc
+++ b/src/qml/doc/src/qmlfunctions.qdoc
@@ -730,16 +730,6 @@
 */
 
 /*!
-  \fn int qmlRegisterType()
-  \relates QQmlEngine
-  \overload
-  \deprecated
-
-  Do not use this function. For anonymous type registrations, use \l qmlRegisterAnonymousType(),
-  and make sure to provide a URI and a major version.
-*/
-
-/*!
     \fn int qmlRegisterInterface(const char *typeName)
     \relates QQmlEngine
 
diff --git a/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc b/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
index fdba452271..7fe678b434 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
@@ -49,7 +49,7 @@ types and JavaScript resources into a given namespace.
 
 The generic form of a module import is as follows:
 \code
-import <ModuleIdentifier> <Version.Number> [as <Qualifier>]
+import <ModuleIdentifier> [<Version.Number>] [as <Qualifier>]
 \endcode
 
 \list
@@ -59,7 +59,9 @@ import <ModuleIdentifier> <Version.Number> [as <Qualifier>]
   \li The \c <Version.Number> is a version of the form
       \c {MajorVersion.MinorVersion} which specifies which definitions of
       various object types and JavaScript resources will be made available due
-      to the import.
+      to the import. It can be omitted, in which case the latest version of the
+      module is imported. It is also possible to only omit the minor version.
+      Then the latest minor version of the given major version is imported.
   \li The \c <Qualifier> is an optional local namespace identifier into which
       the object types and JavaScript resources provided by the module will be
       installed, if given.  If omitted, the object types and JavaScript
@@ -69,7 +71,7 @@ import <ModuleIdentifier> <Version.Number> [as <Qualifier>]
 
 An example of an unqualified module import is as follows:
 \code
-import QtQuick 2.0
+import QtQuick
 \endcode
 
 This import allows the use of all of the types provided by the \c QtQuick
@@ -77,7 +79,7 @@ module without needing to specify a qualifier.  For example, the client code to
 create a rectangle is as follows:
 
 \qml
-import QtQuick 2.0
+import QtQuick
 
 Rectangle {
     width: 200
@@ -86,9 +88,16 @@ Rectangle {
 }
 \endqml
 
+An example of an unqualified import with version would be
+\code
+import QtQuick 2.10
+\endcode
+In that case, any types defined in QtQuick 2.11 and higher or in any higher major
+version, like 6.0, would not be available to the file.
+
 An example of a qualified module import is as follows:
 \code
-import QtQuick 2.0 as Quick
+import QtQuick as Quick
 \endcode
 
 This import allows multiple modules which provide conflicting type names to be
@@ -100,7 +109,7 @@ An example of client code which creates a rectangle after using a qualified
 module import is as follows:
 
 \qml
-import QtQuick 2.0 as Quick
+import QtQuick as Quick
 
 Quick.Rectangle {
     width: 200
@@ -149,7 +158,7 @@ references to types from the \c QtQuick module must be prefixed with the
 \c CoreItems name:
 
 \qml
-import QtQuick 2.0 as CoreItems
+import QtQuick as CoreItems
 
 CoreItems.Rectangle {
     width: 100; height: 100
@@ -171,7 +180,7 @@ two modules can be imported into different namespaces to ensure the code is
 referring to the correct type:
 
 \qml
-import QtQuick 2.0 as CoreItems
+import QtQuick as CoreItems
 import "../textwidgets" as MyModule
 
 CoreItems.Rectangle {
@@ -244,8 +253,8 @@ module by importing the module and using the identifier associated with a
 declared resource:
 
 \qml
-import QtQuick 2.0
-import projects.MyQMLProject.MyFunctions 1.0
+import QtQuick
+import projects.MyQMLProject.MyFunctions
 
 Item {
     Component.onCompleted: { SystemFunctions.cleanUp(); }
@@ -257,9 +266,9 @@ resource identifiers must be prefixed with the namespace qualifier in order
 to be used:
 
 \qml
-import QtQuick 2.0
-import projects.MyQMLProject.MyFunctions 1.0 as MyFuncs
-import org.example.Functions 1.0 as TheirFuncs
+import QtQuick
+import projects.MyQMLProject.MyFunctions as MyFuncs
+import org.example.Functions as TheirFuncs
 
 Item {
     Component.onCompleted: {
diff --git a/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc b/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc
index 8cc13e5e9c..4cb438f85d 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc
@@ -85,7 +85,9 @@ This type of signal is a \e {property change signal} and signal handlers for
 these signals are written in the form \e on<Property>Changed, where
 \e <Property> is the name of the property, with the first letter capitalized.
 
-For example, the \l MouseArea type has a \l {MouseArea::pressed}{pressed} property. To receive a notification whenever this property changes, write a signal handler named \c onPressedChanged:
+For example, the \l MouseArea type has a \l {MouseArea::pressed}{pressed} property.
+To receive a notification whenever this property changes, write a signal handler
+named \c onPressedChanged:
 
 \qml
 import QtQuick
@@ -104,6 +106,55 @@ Even though the \l TapHandler documentation does not document a signal handler
 named \c onPressedChanged, the signal is implicitly provided by the fact that
 the \c pressed property exists.
 
+\section2 Signal parameters
+
+Signals might have parameters. To access those, you should assign a function to the handler. Both
+arrow functions and anonymous functions work.
+
+For the following examples, consider a Status component with an errorOccurred signal (see
+\l{Adding signals to custom QML types} for more information about how signals can be added to
+QML components).
+
+\qml
+// Status.qml
+import QtQuick
+
+Item {
+    id: myitem
+    signal errorOccurred(message: string, line: int, column: int)
+}
+\endqml
+
+\qml
+Status {
+    onErrorOccurred: (mgs, line, col) => console.log(`${line}:${col}: ${msg}`)
+}
+\endqml
+
+\note The names of the formal parameters in the function do not have to match those in the
+signal.
+
+If you do not need to handle all parameters, it is possible to omit trailing ones:
+\qml
+Status {
+    onErrorOccurred: function (message) { console.log(message) }
+}
+\endqml
+
+It is not possible to leave out leading parameters you are interested in, however you can use some
+placeholder name to indicate to readers that they are not important:
+\qml
+Status {
+    onErrorOccurred: (_, _, col) => console.log(`Error happened at column ${col}`)
+}
+\endqml
+
+\note Instead of using a function, it is possible, but discouraged, to use a plain code block. In
+that case all signal parameters get injected into the scope of the block. However, this can make
+code difficult to read as it's unclear where the parameters come from, and results in slower
+lookups in the QML engine. Injecting parameters in this way is deprecated, and will cause runtime
+warnings if the parameter is actually used.
+
 \section2 Using the Connections type
 
 In some cases it may be desirable to access a signal outside of the object that