qmltc: Enforce basic required properties

Types in QML can expose "required" properties.

A required property is a property that should be initialized when an
instance of the type is built.

Instantiating a type without initializing its required properties is an
hard error.

Currently, `qmltc` generated types do not respect the semantic of
"required" properties.

Instead, `qmltc` will generally default-initialize a required property
without notifying the user of the error.

`qmtlc`, so as to respect the semantic of required properties, will now
require the user to pass an initial value for all required properties at
construction time.

To do so, `qmltc` will now generate a new inner record,
`RequiredPropertiesBundle`, for each compiled top-level type, that
contains the required amount of data to initialize each top-level
required property that is reachable from the compiled type.

An instance of `RequiredPropertiesBundle` will be required, as long as
the type presents at least one required property, in the user-facing
constructor for the generated type.

The information stored in the instance will later be used to provide an
initial value for each required property during the construction of the
component.

An intermediate representation for `RequiredPropertiesBundle` was added
to "qmltcoutputir.h".
`QmltcCodeWriter`, the component responsible for writing the final C++
code, was modified to take into consideration the presence, or lack
thereof, of a `RequiredPropertiesBundle` and output the necessary code
when required.

The code taking care of populating the various IRs was modified to
populate a `RequiredPropertiesBundle` for top-level components as
necessary.
Similarly, the code populating the parameters of the user-facing
constructor was modified to require an instance of
`RequiredPropertiesBundle` when necessary.

The code that populates the body of the user-facing constructor for
top-level types was modified to make use of the parameter by tying into
the existing structure for setting initial values.

`qmltc` uses a user-provided callback to allow the user to set the
initial values for properties when constructing a top-level component.

The body of the user-facing constructor was modified to compose the
user-provided callback with a callable that sets the initial values for
top-level required properties based on the bundle of data in the new
`RequiredPropertiesBundle` instance.

The code that populates the body of the user-facing constructor was
moved into its own free-function, `compileRootExternalConstructorBody`,
to be slightly more explicit about the structure of the code.

A new test was provided to evaluate, some basic cases for the new
behavior. Some pre-existing tests, which made use of required
properties, were modified to comply with the new generated API.

The documentation for `qmltc` was modified with a note about the new
behavior.

Task-number: QTBUG-120698
Change-Id: I1e916dcd91ae976629dad8adc7eacc6390bce7e9
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>

1 files changed, 4 insertions, 0 deletions

diff --git a/src/qml/doc/src/tools/qtquickcompiler/qtqml-qml-type-compiler.qdoc b/src/qml/doc/src/tools/qtquickcompiler/qtqml-qml-type-compiler.qdoc
index dc525f3428..38f8fe039b 100644
--- a/src/qml/doc/src/tools/qtquickcompiler/qtqml-qml-type-compiler.qdoc
+++ b/src/qml/doc/src/tools/qtquickcompiler/qtqml-qml-type-compiler.qdoc
@@ -115,6 +115,10 @@ object in C++ is equivalent to creating a new object through
 QQmlComponent::create(). Once created, the object could be manipulated from C++
 or, for example, combined with QQuickWindow to be drawn on screen.
 
+If a compiled type exposes some required properties, `qmltc` will
+require an initial value for those properties in the constructor for
+the generated object.
+
 Additionally, the constructor for a qmltc object can be provided with
 with a callback to set up initial values for the component's
 properties.