1 files changed, 195 insertions, 0 deletions
diff --git a/tools/qmltc/qmltcoutputir.h b/tools/qmltc/qmltcoutputir.h
new file mode 100644
index 0000000000..de531f718d
--- /dev/null
+++ b/tools/qmltc/qmltcoutputir.h
@@ -0,0 +1,195 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef QMLTCOUTPUTIR_H
+#define QMLTCOUTPUTIR_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qset.h>
+
+#include <private/qqmljsmetatypes_p.h>
+
+#include <optional>
+
+QT_BEGIN_NAMESPACE
+
+// Below are the classes that represent compiled QML types in a string data
+// form. These classes are used to generate C++ code.
+
+// Represents C++ variable
+struct QmltcVariable
+{
+    QString cppType; // C++ type of a variable
+    QString name; // variable name
+    QString defaultValue; // optional initialization value
+
+    QmltcVariable() = default;
+    // special ctor for QList's emplace back
+    QmltcVariable(const QString &t, const QString &n, const QString &v = QString())
+        : cppType(t), name(n), defaultValue(v)
+    {
+    }
+};
+
+struct QmltcProperty : QmltcVariable
+{
+    QString containingClass;
+    QString signalName;
+
+    QmltcProperty() = default;
+    QmltcProperty(const QString t, const QString &n, const QString &c, const QString &s)
+        : QmltcVariable(t, n), containingClass(c), signalName(s)
+    {
+    }
+};
+
+// Represents QML -> C++ compiled enumeration type
+struct QmltcEnum
+{
+    QString cppType; // C++ type of an enum
+    QStringList keys; // enumerator keys
+    QStringList values; // enumerator values
+    QString ownMocLine; // special MOC line that follows enum declaration
+
+    QmltcEnum() = default;
+    QmltcEnum(const QString &t, const QStringList &ks, const QStringList &vs, const QString &l)
+        : cppType(t), keys(ks), values(vs), ownMocLine(l)
+    {
+    }
+};
+
+struct QmltcMethodBase
+{
+    QStringList comments; // C++ comments
+    QString name; // C++ function name
+    QList<QmltcVariable> parameterList; // C++ function parameter list
+    QStringList body; // C++ function code
+    QQmlJSMetaMethod::Access access = QQmlJSMetaMethod::Public; // access specifier
+    QStringList declarationPrefixes;
+    QStringList modifiers; // cv-qualifiers, ref-qualifier, noexcept, attributes
+};
+
+// Represents QML -> C++ compiled function
+struct QmltcMethod : QmltcMethodBase
+{
+    QString returnType; // C++ return type
+    QQmlJSMetaMethodType type = QQmlJSMetaMethodType::Method; // Qt function type
+
+    // TODO: should be a better way to handle this
+    bool userVisible = false; // tells if a function is prioritized during the output generation
+};
+
+// Represents C++ ctor of a type
+struct QmltcCtor : QmltcMethodBase
+{
+    QStringList initializerList; // C++ ctor's initializer list
+};
+
+// Represents C++ dtor of a type
+struct QmltcDtor : QmltcMethodBase
+{
+};
+
+// Represents a generated class that knows how to set the public,
+// writable properties of a compiled QML -> C++ type.
+// This is generally intended to be available for the root of the
+// document to allow the user to set the initial values for
+// properties, when creating a component, with support for strong
+// typing.
+struct QmltcPropertyInitializer {
+    QString name;
+
+    QmltcCtor constructor;
+
+    // A member containing a reference to the object for which the
+    // properties should be set.
+    QmltcVariable component;
+
+    // A member containing a cache of properties that were actually
+    // set that can be referenced later..
+    QmltcVariable initializedCache;
+
+    // Setter methods for each property.
+    QList<QmltcMethod> propertySetters;
+};
+
+// Represents a generated class that contains a bundle of values to
+// initialize the required properties of a type.
+//
+// This is generally intended to be available for the root component
+// of the document, where it will be used as a constructor argument to
+// force the user to provide initial values for the required
+// properties of the constructed type.
+struct QmltcRequiredPropertiesBundle {
+    QString name;
+
+    QList<QmltcVariable> members;
+};
+
+// Represents QML -> C++ compiled type
+struct QmltcType
+{
+    QString cppType; // C++ type of the QML type
+    QStringList baseClasses; // C++ type names of base classes
+    QStringList mocCode; // Qt MOC code
+    QStringList otherCode; // Random code that doesn't fit any category, e.g. friend declarations
+
+    // member types: enumerations and child types
+    QList<QmltcEnum> enums;
+    QList<QmltcType> children; // these are pretty much always empty
+
+    // special member functions:
+    QmltcCtor baselineCtor {}; // does basic contruction
+    QmltcCtor externalCtor {}; // calls basicCtor, calls init
+    QmltcMethod init {}; // starts object initialization (context setup), calls finalize
+    QmltcMethod beginClass {}; // calls QQmlParserStatus::classBegin()
+    QmltcMethod endInit {}; // ends object initialization (with "simple" bindings setup)
+    QmltcMethod setComplexBindings {}; // sets up "complex" (e.g. script) bindings
+    QmltcMethod completeComponent {}; // calls QQmlParserStatus::componentComplete()
+    QmltcMethod finalizeComponent {}; // calls QQmlFinalizerHook::componentFinalized()
+    QmltcMethod handleOnCompleted {}; // calls Component.onCompleted
+
+    std::optional<QmltcDtor> dtor {};
+
+    // member functions: methods, signals and slots
+    QList<QmltcMethod> functions;
+    // member variables
+    QList<QmltcVariable> variables;
+    QList<QmltcProperty> properties;
+
+    // QML document root specific:
+    std::optional<QmltcMethod> typeCount; // the number of QML types defined in a document
+
+    // TODO: only needed for binding callables - should not be needed, generally
+    bool ignoreInit = false; // specifies whether init and externalCtor should be ignored
+
+    // needed for singletons
+    std::optional<QmltcMethod> staticCreate{};
+
+    // A proxy class that provides a restricted interface that only
+    // allows setting the properties of the type.
+    QmltcPropertyInitializer propertyInitializer{};
+
+    std::optional<QmltcRequiredPropertiesBundle> requiredPropertiesBundle{};
+};
+
+// Represents whole QML program, compiled to C++
+struct QmltcProgram
+{
+    QString url; // QML file url
+    QString cppPath; // C++ output .cpp path
+    QString hPath; // C++ output .h path
+    QString outNamespace;
+    QString exportMacro; // if not empty, the macro that should be used to export the generated
+                         // classes
+    QSet<QString> includes; // non-default C++ include files
+    QmltcMethod urlMethod; // returns QUrl of the QML document
+
+    QList<QmltcType> compiledTypes; // all QML types that are compiled to C++
+};
+
+QT_END_NAMESPACE
+
+#endif // QMLTCOUTPUTIR_H