It turned every file down. Two mistakes, each enough on its own.

What loadFile() hands its callback is the metadata about the file, of
which the file itself is a field, so the check that what was loaded is a
QmlFile was asking the metadata, which is an ExternalItemInfo and never
a QmlFile. Ask the file, the way the option that dumps the syntax tree
already does.

The index the loaded files are put at was never advanced, so every file
after the first was dropped and the slots they should have gone in
stayed empty. An empty slot is not a QmlFile either, which is the other
way the same message came out.

With both fixed it writes what qmlformat writes: --reformat over a file
gives what qmlformat --normalize gives, byte for byte, since the dom
writes the script of a file through the same formatter and the options
it reformats with are the normalising ones.

Amends 4cfb323389363bf12f84044b8c7501ef2f0441b9

Task-number: QTBUG-151040
Pick-to: 6.12 6.8
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Change-Id: Ibb38e0f422ebdf8991dbbc45208acbc1e4abf036
Reviewed-by: Semih Yavuz <semih.yavuz@qt.io>

Amends commit 265c9250df853df1110ca4c2545b100481b98a2e.

Pick-to: 6.12
Change-Id: Ibe18bc49a59e93a48341d204dcc238f366d60e55
Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>

Make qmllint warn when MaxWarnings is not respected. This should help
spot the current number of warnings more easily when trying to set
MaxWarnings to an initial value on a QML project with QML warnings.

Make the new max-warnings-exceeded warning category an Error so that
qmllint returns a non-zero exit code when exceeding MaxWarnings, an
remove the custom logic in qmllint/main.cpp that set success to false.
The new category is Essential so that users can't downgrade it via
commandline or settings files.

Note that qmllint can override MaxWarnings from the settings file with
its command-line parameter, while qmlls only accepts MaxWarnings from
the settings file.

Fixes: QTBUG-150177
Change-Id: Ia5e9e360d5fa495d9cf80f48e4074dddf161bdd4
Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>

Introduce a new settings class for Qmllint that inherits from
QQmlToolingSettings, just like QQmlFormatSettings. This is needed for
QTBUG-150177 so that we can add a static const inline member for the
MaxWarnings key name.

Task-number: QTBUG-150177
Change-Id: Ie8900679f10a84e8794bf21f5a957224f7e69955
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>

This implements private API for loading a QQuickVectorImage from
a QByteArray directly instead of going via a file. It exists for the
purpose of fuzz testing, to avoid having to save fuzzed content to
a file before testing it.

Pick-to: 6.12
Task-number: QTBUG-148828
Change-Id: I69e1df5ec116a7de826cfba2bf5b28b7987178d8
Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>

Disable the building of qmlcontextpropertydump when crosscompiling with
a host that does not have qmlcontextpropertydump (e.g., when the
qmlcontextpropertydump feature is disabled on the host).

Pick-to: 6.12
Fixes: QTBUG-148180
Change-Id: I3d821e2bb4ee02c23e303958320714801fc1a1f9
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

Before a37e4270a5e66507aeda483ec4d32262096b44cc, qmllint used to create
up to two qqmljsscopes for each file it got as command line parameters.

a37e4270a5e66507aeda483ec4d32262096b44cc enhanced this situation by
avoiding the duplicate scopes, but still processed each file twice (once
by the LinterVisitor for the actual linting and once via lazy-loading
when the file gets pulled in as dependency for another file to be linted).
This lead to QTBUG-146688 where processing the same file into the same
scope has some buggy side-effects and breaks the assumption that
lazy-loaded scopes are never modified after creation.

This patch addresses this issue by making qmllint process each
QML file from its command line once by merging the linting process
and the lazy-loading mechanism together.

Rework QmlJSLinter to work in two stages:
1. collect all files to be linted with prepareFileForBatchLinting()
2. do the actual linting with lintFileInBatch()

 -- Stage 1:
In prepareFileForBatchLinting, set up the file-to-be-linted with a
linting factory to lazy-load it via LinterVisitor instead of
QQmlJSImportVisitor.

"unprepared" files needed by the file-to-be-linted are still loaded
via QQmlJSImportVisitor.

 -- Stage 2:
In lintFile, populate the lazy file if needed and continue with the
rest of the linting process.
At this stage, the QQmlJSScopes of the QML files used by the
current-QML-file-to-be-linted can be populated via lazy construction,
which means that cycle references can be resolved. A first attempt
where all the linting pipeline ran during lazy-loading in stage 1 was
unsuccessful at resolving cyclic dependencies between files.

Remove m_logger from QQmlJSLinter: there may be multiple active loggers,
for example when lazy-loading a file via LinterVisitor during the
linting process of another file.

To avoid QTBUG-146688, make prepareForBatchLinting() return false when
linting would re-populate an already populated scope.
Re-populating a scope breaks all the references to its children which
leads to QTBUG-146688.

Adapt qmllint/main.cpp to prepare all file passed by commandline before
starting to lint them.

Adapt tst_qmllint to:
* simulate clean snippet scope that are actually reused. Snippets
  are not used by other QML code so their scope and children can
  safely be deleted.
* clear the cache when scope re-populating happens on non-snippets. Note
  that clearing the cache for each linted file would be cleaner but
  increases the test runtime by a factor of 2.5x.

Fixes: QTBUG-146688
Change-Id: Ibc7586501388988d60d8ca0fbfff4949ed3c3c22
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

This is modeled after the interactive mode that qmlprofiler already
offers. You can store the event stream into a .qtd file, and replay it.
In contrast to qmlprofiler, you can also kill and re-start the
application. That is handy if you notice the preview couldn't handle
some change and want to replay the stored input events into a clean
slate.

Pick-to: 6.12
Task-number: QTBUG-146122
Change-Id: Ic0086e4f4b6c837a6bf1210430eeceb722b80cb7
Reviewed-by: Semih Yavuz <semih.yavuz@qt.io>

Factor the interactive command-line mechanism that was open-coded in
qmlprofiler into QmlDebugPrivate so that other QML debugging tools can
reuse it.

We move qmlprofiler's console handling into QmlDebug: QQmlDebugConsole
owns a QQmlDebugCommandListener on a worker thread, dispatches lines to
registered command handlers, renders a generated help listing and offers
a reusable yes/no confirmation flow. The listener keeps a single
persistent QTextStream and reports end-of-input so consumers can quit
when standard input is closed.

Pick-to: 6.12
Task-number: QTBUG-146122
Change-Id: I237dce26026fd520cbab25efcf5ce08d25507c92
Reviewed-by: Semih Yavuz <semih.yavuz@qt.io>

Nothing particularly bad, but GCC warns about it:

/qt/qtdeclarative/tools/qmltc/main.cpp:36:21: warning: loop variable
'<structured bindings>' creates a copy from type 'const
std::pair<QQmlSA::LoggerWarningId,
std::optional<QQmlSA::WarningSeverity> >' [-Wrange-loop-construct]
   36 |     for (const auto [id, catOverride] :
QQmltc::categoryOverrides()) {
      |                     ^~~~~~~~~~~~~~~~~
/qt/qtdeclarative/tools/qmltc/main.cpp:36:21: note: use reference type
to prevent copying
   36 |     for (const auto [id, catOverride] :
QQmltc::categoryOverrides()) {
      |                     ^~~~~~~~~~~~~~~~~
      |                     &

Amends 39742e8930cfc24d19a10ce213ee647a1adb2117

Pick-to: 6.12 6.11
Change-Id: Ic1f1b6b867ed1660045cff95eb07bfc9e2836489
Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>